Maze solving
You are encouraged to solve this task according to the task description, using any language you may know.
For a maze generated by this task, write a function that finds (and displays) the shortest path between two cells. Note that because these mazes are generated by the Depth-first search algorithm, they contain no circular paths, and a simple depth-first tree search can be used.
D
Basic define <lang d>import std.stdio, std.random ;
immutable string[] Tiles =
[" ","╞","╥","╔","╡","═", "╗","╦","╨","╚","║","╠","╝","╩","╣","╬"] ;
immutable string[] Paths =
[" "," "," ","┌"," ","─", "┐"," "," ","└","│"," ","┘"," "," "," "] ;
alias uint Room ; enum Open { EMPTY = 0U , EAST = 1, SOUTH = 2, WEST = 4, NORTH = 8,
EPATH = 16, SPATH = 32, WPATH = 64, NPATH = 128, ENTRY = 256, EXIT = 512, Visited = 1024 }
struct Where {
immutable int x, y ; Where opBinary(string op)(Where rhs) if (op=="+") { return Where(x + rhs.x, y + rhs.y) ; } bool bounded(int w, int h) { return (x >= 0 && y >= 0 && x < w && y < h) ; } bool bounded(Room[][] r) { return (x >= 0 && y >= 0 && r.length > 0 && y < r.length && x < r[0].length ) ; }
} struct Door { Open opening = Open.EMPTY ; Where where ; alias where this ; }
immutable Open[Open] Opposite ; immutable Where[Open] NeibrPos ;
static this() { // workarround for Associative Array init.
Opposite = [Open.EAST:Open.WEST, Open.SOUTH:Open.NORTH, Open.WEST:Open.EAST, Open.NORTH:Open.SOUTH] ; NeibrPos = [Open.EAST:Where( 1,0), Open.SOUTH:Where(0, 1), Open.WEST:Where(-1,0), Open.NORTH:Where(0,-1)] ;
}
const AsPath = true ;
void connectTo(ref Room[][] r, Door d, bool asPath = false) {
auto s/*hift*/ = asPath ? 4 : 0 ; r[d.y][d.x] |= (d.opening << s) ; auto there = d.where + NeibrPos[d.opening] ; if(there.bounded(r)) r[there.y][there.x] |= (Opposite[d.opening] << s) ;
} bool connected(ref Room[][] r, Door d) {
auto there = d.where + NeibrPos[d.opening] ; return (r[ d.y][ d.x] & d.opening) && there.bounded(r) && (r[there.y][there.x] & Opposite[d.opening]) ;
}
void printMaze(Room[][] maze, bool showPath = false) {
foreach(row ; maze) { foreach(cell;row) if(showPath) write(Paths[0xf & (cell >> 4)]) ; else write(Tiles[0xf & (cell)]) ; writeln() ; }
} </lang> Generate Maze: <lang d>Room[][] genMaze(uint w, uint h, ref Door entry = Door.init, ref Door exit = Door.init) {
Room[][] r = new Room[][](h, w) ; // default value = 0 means un-visited empty room
bool validDoor(Door d) { if(d.where.bounded(w,h)) switch(d.opening) { case Open.EAST : return (d.x == w - 1) ; case Open.WEST : return (d.x == 0) ; case Open.NORTH: return (d.y == 0) ; case Open.SOUTH: return (d.y == h - 1) ; } return false ; }
Door makeDoor() { // create door at random edge switch([Open.EAST, Open.WEST, Open.NORTH, Open.SOUTH][uniform(0,4)]) { case Open.EAST : return Door(Open.EAST , Where(w-1, uniform(0,h))) ; case Open.WEST : return Door(Open.WEST , Where( 0, uniform(0,h))) ; case Open.NORTH: return Door(Open.NORTH, Where(uniform(0,w), 0)) ; case Open.SOUTH: return Door(Open.SOUTH, Where(uniform(0,w), h-1)) ; } }
Open[] neibrDir = NeibrPos.keys ;
// depth-first search algorithm to generate maze void visit(Where here) { r[here.y][here.x] |= Open.Visited ; randomShuffle(neibrDir) ; foreach(dir; neibrDir) { auto there = here + NeibrPos[dir] ; if(there.bounded(w,h)) // bounded? if((r[there.y][there.x] & Open.Visited) == 0) { // un-visited? connectTo(r, Door(dir, here)) ; visit(there) ; } } }
// make entry & exit doors if not provided or invalid while(entry.opening == Open.EMPTY || entry.where == exit.where || !validDoor(entry)) entry = makeDoor() ; while( exit.opening == Open.EMPTY || entry.where == exit.where || !validDoor(exit)) exit = makeDoor() ; r[entry.y][entry.x] |= (entry.opening | Open.ENTRY) ; r[ exit.y][ exit.x] |= ( exit.opening | Open.EXIT) ;
// generate maze starting from entry visit(entry.where) ;
return r ;
}</lang> Solver: <lang d>bool solveMaze(ref Room[][] r, Door entry, Door exit ) {
Open[] neibrDir = NeibrPos.keys ;
foreach(row ; r) // clear old path, if any foreach(cell;row) cell &= ~(Open.EPATH|Open.WPATH|Open.SPATH|Open.NPATH) ;
bool trace(Door here) { if(here.where == exit.where) { // reach exit r.connectTo(exit, AsPath) ; return true ; } foreach(dir ; neibrDir) { // here.opening is direction to enter the room@here // _dir_ is direction to exit the room@here, which is opposite to there.opening if( (dir != here.opening) && ((dir & r[here.y][here.x]) != 0)) { // path exist? auto there = Door(Opposite[dir], here.where + NeibrPos[dir]) ; if( there.bounded(r)) if(trace(there)) { // reach exit, use stack to trace back the path r.connectTo(Door(dir, here.where), AsPath) ; return true ; } } } return false ; // dead end }
auto success = trace(entry) ; if(success) r.connectTo(entry, AsPath) ; return success ;
}</lang> Sample run: <lang d>void main() {
Door entry, exit; auto maze = genMaze(40, 12, entry, exit) ;
printMaze(maze) ; if(solveMaze(maze, entry, exit)) printMaze(maze, AsPath) ; else writeln("No solution!?") ;
}</lang> Output:)
╔═╗╞╗╔╡╔══╗╔╦╗╔═╗╞╗╔═══╦══╗╞╗╔═╗╔╦╗╚╗╞═╗ ╚╗╚═╝╠╗║╔╗╚╝║║║╞╩═╝╚╗╔═╝╔╗╠═╝╠╡╠╝╨╚╗╚═╦╝ ╔╝╔══╝╚╩╝╚╡╔╝║╠════╗║╚═╗║║║╔╗║╔╝╔══╩═╡╚╗ ╠╗║╔╗╔═╗╥╔╗║╥║╨╔╗╔╗║║╞╗║╨╚╝║╚╝║╥║╞╦╗╔╦╡║ ║╚╝╨╚╣╔╩╣║╚╝║╚╗║╚╝╚╣╚╦╝╚╗╔═╝╞╗║║╠╗║║║╚╗║ ╚═══╗╨╚╗║║╔╡╚╗╚╣╥╔╗╚╗╚╗╥║╚═╗╔╝║║║╚╝╨║╥║║ ╔═══╝╔═╣║╚╩═╗║╔╝╚╝╚═╝╔╝║╚═╗║╚╗║╠╝╔══╝║╚╝ ╚═╗╔═╝╞╝╚═╗╔╝║╚╗╔═╗╔╗║╞╬╗╥║╚╗║║╠╡╚══╗╚═╗ ╔═╝║╔╗╔═╗╔╝╚╗╚╦╝║╥╚╝╚╝╔╝╚╣╚╗║║║╨╔══╗╚╗╔╣ ╩══╝║╚╝╥╠╝╞╗║╥║╔╝╠╦╗╔╗╚═╗╚╗║║║╚═╝╔╡║╔╩╝╨ ╔╡╔╦╝╔═╣╚═╗║║╚╝║╞╝║║╨╠══╝╥║╠╝╠╗╞═╣╔╝╚══╗ ╚═╝╚═╝╞╝╞═╩╝╚══╩══╝╚═╝╞══╩╝╚═╝╚══╝╚════╝
┌──┐┌┐ ┌───┐ ┌─┐ └┐ ┌┐│ └┘│ └┐┌─┘ │ │ └─┐ ┌──┘└┘ ┌┘ │└─┐ ┌┐│┌┘ └┐ ┌┐│ ┌┐│ │ │ │└┘│ ┌┐ │ │└┘ │└┘ └┐ └┐┌─┘ │ │└┐│ └───┐ │ └┐ │└─┐ │ │ ││ ┌───┘ └──┐ ┌┘ └─┐│ │ ┌──┘ └┘ └─┐ ┌┘ ┌─┐┌┐│ │└┐ │ └──┐ ┌─┘ └┐ │ └┘└┘ └┐│ │ ┌──┐└┐ ┘ │ ┌┘ ││ └─┘ │┌┘ │ │ └┘ ┌┘└──┐ └──┘ └────┘
J
<lang J> NB. source Dijkstra_equal_weights graph NB. NB. + +---+---+ NB. | 0 1 2 | (sample cell numbers) NB. +---+ + + NB. | 3 4 | 5 NB. +---+---+---+ NB. NB. graph =: 1;0 2 4;1 5;4;1 3;2 NB. The graph is a vector of boxed vectors of neighbors.
Dijkstra_equal_weights =: 4 : 0
dist =. previous =. #&_ n =. # graph =. y [ source =. x dist =. 0 source } dist Q =. 0 while. #Q do. u =. {.Q Q =. }.Q if. _ = u{dist do. break. end. for_v. >u{graph do. if. -. v e. previous do. alt =. >: u { dist if. alt < v { dist do. dist =. alt v } dist previous =. u v } previous if. v e. Q do. echo 'belch' else. Q =. Q,v end. end. end. end. end. dist;previous
)
path =. 3 : 0
p =. <:#y while. _ > {:p do. p =. p,y{~{:p end. |.}:p
)
solve=:3 :0
NB. convert walls to graph shape =. }.@$@:> ew =. (,.&0 ,: 0&,.)@>@{. NB. east west doors ns =. (, &0 ,: 0&, )@>@{: cell_offsets =. 1 _1 1 _1 * 2 # 1 , {:@shape cell_numbers =. i.@shape neighbors =. (cell_numbers +"_ _1 cell_offsets *"_1 (ew , ns))y graph =. (|:@(,/"_1) <@-."1 0 ,@i.@shape)neighbors NB. list of boxed neighbors NB. solve it path , > {: 0 Dijkstra_equal_weights graph
)
display=:3 :0 NB. Monadic display copied from maze generation task
size=. >.&$&>/y text=. (}:1 3$~2*1+{:size)#"1":size$<' ' 'hdoor vdoor'=. 2 4&*&.>&.> (#&,{@;&i./@$)&.> y ' ' (a:-.~0 1;0 2; 0 3;(2 1-~$text);(1 4&+&.> hdoor),,vdoor+&.>"0/2 1;2 2;2 3)} text
a=. display y size=. >.&$&>/y columns=. {: size cells =. <"1(1 2&p.@<.@(%&columns) ,. 2 4&p.@(columns&|))x '+' cells } a NB. exercise, replace cells with a gerund to draw arrows on the path.
)
4 (display~ solve)@maze 9
┌ ┬───┬───┬───┬───┬───┬───┬───┬───┐ │ + │ │ │ ├ ┼───┼ ┼ ┼ ┼───┼ ┼ ┼ ┤ │ + + │ │ │ │ │ ├───┼ ┼───┼───┼───┼───┼───┼ ┼───┤ │ │ + + + │ + + + │ │ ├ ┼───┼───┼ ┼ ┼───┼ ┼───┼───┤ │ + + │ + + + └───┴───┴───┴───┴───┴───┴───┴───┴───┘
</lang>
PicoLisp
<lang PicoLisp>(de shortestPath (Goal This Maze)
(let (Path NIL Best NIL Dir " > ") (recur (This Path Dir) (when (and This (not (: mark))) (push 'Path (cons This Dir)) (if (== Goal This) (unless (and Best (>= (length Path) (length Best))) (setq Best Path) ) (=: mark T) (recurse (: west) Path " > ") (recurse (: east) Path " < ") (recurse (: south) Path " \^ ") (recurse (: north) Path " v ") (=: mark NIL) ) ) ) (disp Maze 0 '((Fld) (if (asoq Fld Best) (cdr @) " ")) ) ) )</lang>
Using the maze produced in Maze generation#PicoLisp, this finds the shortest path from the top-left cell 'a8' to the bottom-right exit 'k1':
: (shortestPath 'a8 'k1 (maze 11 8)) + +---+---+---+---+---+---+---+---+---+---+ 8 | > > v | > v | | + + + + + + +---+ +---+---+ + 7 | | | > ^ | v | | | | | +---+ +---+---+ + + +---+ + + + 6 | | | v | | | | | + +---+ +---+ +---+---+---+ + +---+ 5 | | | > > > v | | | +---+ +---+ +---+---+---+ +---+---+ + 4 | | | | | v | > > v | + +---+ +---+ +---+ + + +---+ + 3 | | | | | v | ^ < | v | + +---+---+ + + + + +---+ + + 2 | | | | | | v | > ^ | v | + + + +---+ + +---+ + +---+ + 1 | | | > ^ | > +---+---+---+---+---+---+---+---+---+---+---+ a b c d e f g h i j k
Python
<lang Python>
- python 3
def Dijkstra(Graph, source):
+ +---+---+ | 0 1 2 | +---+ + + | 3 4 | 5 +---+---+---+
>>> graph = ( # or ones on the diagonal ... (0,1,0,0,0,0,), ... (1,0,1,0,1,0,), ... (0,1,0,0,0,1,), ... (0,0,0,0,1,0,), ... (0,1,0,1,0,0,), ... (0,0,1,0,0,0,), ... ) ... >>> Dijkstra(graph, 0) ([0, 1, 2, 3, 2, 3], [1e+140, 0, 1, 4, 1, 2]) >>> display_solution([1e+140, 0, 1, 4, 1, 2]) 5<2<1<0 # Graph[u][v] is the weight from u to v (however 0 means infinity) infinity = 1e140 undefined = 1e140 n = len(graph) dist = [infinity]*n # Unknown distance function from source to v previous = [infinity]*n # Previous node in optimal path from source dist[source] = 0 # Distance from source to source Q = list(range(n)) # All nodes in the graph are unoptimized - thus are in Q while Q: # The main loop Q.sort(key=lambda n:dist[n], reverse=True) # (Not exactly a heap!) # improvement, install heapq from library u = Q.pop() # vertex in Q with smallest dist[] if dist[u] == infinity: break # all remaining vertices are inaccessible from source for v in range(n): # each neighbor v of u if Graph[u][v] and (v in Q): # where v has not yet been visited alt = dist[u] + Graph[u][v] if alt < dist[v]: # Relax (u,v,a) dist[v] = alt previous[v] = u return dist,previous
def display_solution(predecessor):
cell = len(predecessor)-1 while cell: print(cell,end='<') cell = predecessor[cell] print(0)
</lang>
Tcl
This script assumes that the contents of the generation task have already been source
d. Note that the algorithm implemented here does not assume that the maze is free of circuits, and in the case that there are multiple routes, it finds the shortest one because it is a breadth-first search (by virtue of the queue variable being used as a queue).
<lang tcl>oo::define maze {
method solve {} {
### Initialization of visited matrix and location/path queue set visited [lrepeat $x [lrepeat $y 0]] set queue {0 0 {}}
### Loop to do the searching ### while 1 { # Check for running out of path; an error in maze construction if {[llength $queue] == 0} { error "cannot reach finish" } # Visit the next square from the queue set queue [lassign $queue cx cy path] if {[lindex $visited $cx $cy]} continue lset visited $cx $cy 1 lappend path $cx $cy # Check for reaching the goal if {$cx == $x-1 && $cy == $y-1} break # Add the square in each direction to the queue if a move there is legal foreach {dx dy} {0 1 1 0 0 -1 -1 0} { set nx [expr {$cx + $dx}]; set ny [expr {$cy + $dy}] if { $nx >= 0 && $nx < $x && $ny >= 0 && $ny < $y && ($dx && idx($verti, min($cx,$nx), $cy) || $dy && idx($horiz, $cx, min($cy,$ny))) } then { lappend queue $nx $ny $path } } }
### Loop to set up the path rendering ### # (-2,-2) is just a marker that isn't next to the maze at all, so # guaranteeing the use of the last 'else' clause foreach {cx cy} $path {nx ny} [concat [lrange $path 2 end] -2 -2] { if {$nx-$cx == 1} { lset content $cx $cy "v" } elseif {$nx-$cx == -1} { lset content $cx $cy "^" } elseif {$ny-$cy == -1} { lset content $cx $cy "<" } else { lset content $cx $cy ">" } }
### Return the path ### return $path
}
}
- Do the solution (we ignore the returned path here...)
m solve
- Print it out
puts [m view]</lang> Example output:
+ +---+---+---+---+---+---+---+---+---+---+ | v | | + +---+ +---+---+---+---+---+---+---+ + | v | | > v | > v | | | + + +---+ + + + + + +---+ + | v | > ^ | v | ^ | v | | | | + +---+ +---+ + + + +---+ +---+ | v | > ^ | v < | ^ | v | | | | + + +---+ +---+ + + +---+ + + | > ^ | v < | > ^ | v | | | +---+---+ +---+ +---+ +---+ +---+---+ | v < < | > ^ | v < | > > > v | + +---+---+ +---+ +---+ +---+---+ + | > v | ^ < | > > ^ | | v | +---+ +---+---+ +---+---+---+ + + + | > > > ^ | | > +---+---+---+---+---+---+---+---+---+---+---+