Maze generation algorithm

Maze generation algorithms are automated methods for the creation of mazes.










Graph theory based methods
A maze can be generated by starting with a predetermined arrangement of cells (most commonly a
rectangular grid but other arrangements are possible) with wall sites between them. This predetermined
arrangement can be considered as a connected graph with the edges representing possible wall sites and
the nodes representing cells. The purpose of the maze generation algorithm can then be considered to be
making a subgraph where it is challenging to find a route between two particular nodes.
If the subgraph is not connected, then there are regions of the graph that are wasted because they do not
contribute to the search space. If the graph contains loops, then there may be multiple paths between the
chosen nodes. Because of this, maze generation is often approached as generating a random spanning tree.
Loops which can confound naive maze solvers may be introduced by adding random edges to the result
during the course of the algorithm.
Depth-first search
This algorithm is a randomized version of the depth-first search algorithm. Frequently implemented with
a stack, this approach is one of the simplest ways to generate a maze using a computer. Consider
the space for a maze being a large grid of cells (like a large chess board), each cell starting with four
walls. Starting from a random cell, the computer then selects a random neighbouring cell that has not
yet been visited. The computer removes the 'wall' between the two cells and adds the new cell to a
stack (this is analogous to drawing the line on the floor). The computer continues this process, with a
cell that has no unvisited neighbours being considered a dead-end. When at a dead-end it backtracks
through the path until it reaches a cell with an unvisited neighbour, continuing the path generation by
visiting this new, unvisited cell (creating a new junction). This process continues until every cell has
been visited, causing the computer to backtrack all the way back to the beginning cell. This approach
guarantees that the maze space is completely visited.

As stated, the algorithm is very simple and does not produce over-complex mazes. More specific
refinements to the algorithm can help to generate mazes that are harder to solve.
1. Start at a particular cell and call it the "exit."
2. Mark the current cell as visited, and get a list of its neighbors. For each neighbor, starting with a
randomly selected neighbor:
1. If that neighbor hasn't been visited, remove the wall between this cell and that neighbor,
and then recurse with that neighbor as the current cell.
The algorithm can be rearranged into a loop by storing backtracking information in the maze itself. This
also provides a quick way to display a solution, by starting at any given point and backtracking to the
exit.
Mazes generated with a depth-first search have a low branching factor and contain many long
corridors. Also mazes will typically be relatively easy to find the way to the square that was first picked
at the beginning of the algorithm, since most paths lead to or from there, but it is hard to find the way
out.
To add difficulty and a fun factor to depth-first search generated mazes, you can influence the likelihood
of which neighbor you should visit, instead of it being completely random. By making it more likely to
visit neighbors to your sides, you can have a more horizontal maze generation. Experimenting with
directional "influence" in certain places could lead to creating fun designs, such as a checkerboard
pattern, an X, and more.
Recursive backtracker
The depth-first search algorithm of maze generation is frequently implemented using backtracking:
1. Make the initial cell the current cell and mark it as visited
2. While there are unvisited cells
1. If the current cell has any neighbours which have not been visited
1. Choose randomly one of the unvisited neighbours
2. Push the current cell to the stack
3. Remove the wall between the current cell and the chosen cell
4. Make the chosen cell the current cell and mark it as visited
2. Else if stack is not empty
1. Pop a cell from the stack
2. Make it the current cell
3. Else
1. Pick a random unvisited cell, make it the current cell and mark it as visited


Randomized Kruskal's algorithm

This algorithm is a randomized version of Kruskal's algorithm.
1. Create a list of all walls, and create a set for each cell, each containing just that one cell.
2. For each wall, in some random order:
1. If the cells divided by this wall belong to distinct sets:
1. Remove the current wall.
2. Join the sets of the formerly divided cells.
There are several data structures that can be used to model the sets of cells. An efficient
implementation using a disjoint-set data structurecan perform each union and find operation on two sets
in nearly constant amortized time (specifically, time; for any plausible value
of ), so the running time of this algorithm is essentially proportional to the number of walls available to
the maze.
It matters little whether the list of walls is initially randomized or if a wall is randomly chosen from a
nonrandom list, either way is just as easy to code.
Because the effect of this algorithm is to produce a minimal spanning tree from a graph with equally
weighted edges, it tends to produce regular patterns which are fairly easy to solve.

This algorithm is a randomized version of Prim's algorithm.
1. Start with a grid full of walls.
2. Pick a cell, mark it as part of the maze. Add the walls of the cell to the wall list.
3. While there are walls in the list:
1. Pick a random wall from the list. If the cell on the opposite side isn't in the maze yet:
i. Make the wall a passage and mark the cell on the opposite side as part of the maze.
ii. Add the neighboring walls of the cell to the wall list.
2. If the cell on the opposite side already was in the maze, remove the wall from the list.
Like the depth-first algorithm, it will usually be relatively easy to find the way to the starting cell, but hard
to find the way anywhere else.
Note that simply running classical Prim's on a graph with random weights would create mazes
stylistically identical to Kruskal's, because they are both minimal spanning tree algorithms. Instead, this
algorithm introduces stylistic variation because the edges closer to the starting point have a lower
effective weight.
Modified version[edit]
Although the classical Prim's algorithm keeps a list of edges, for maze generation we could instead
maintain a list of adjacent cells. If the randomly chosen cell has multiple edges that connect it to the
existing maze, select one of these edges at random. This will tend to branch slightly more than the
edge-based version above