I use a 15/23 element integer array to represent the burrow, numbering like this:
•••••••••••••••••••
•0 1. 2. 3. 4. 5 6•
••••7 •8 •9 •10••••
•11•12•13•14•
•••••••••••••
I started writing writing a Dijkstra-based Python solution. It turned out to be
extremely slow, so I abandoned it. A couple of friends pointed out that it's
possible to just manually solve Part 1 so I ended up doing that, re-using much
of my Python code to check moves, visualize the state and keeping track of
moves. I used an ipython shell, imported the code and experimented, e.g. the
example starts as:
> import part1
> s = part1.input
> s
#############
#...........#
###B#C#B#D###
#A#D#C#A#
#########
0
> s.move(9,2)
#############
#...B.......#
###B#C#.#D###
#A#D#C#A#
#########
40
> s.move(8,9)
#############
#...B.......#
###B#.#C#D###
#A#D#C#A#
#########
440
> s.move(12,3)
#############
#...B.D.....#
###B#.#C#D###
#A#.#C#A#
#########
3440
and so on.
For part 2, I started by extending the code to work on the larger burrow and
tried playing around as well, but doing it manually turned out to not work very
well. So I went back to writing code, but I used Go, to make it reasonably fast
(and eliminate a significant source of bugs, because I don't know Python very
well).
It's probably possible to optimize this a lot, but the Go code ended up being
reasonably fast.