Random Acyclic Maze Generator with given Entry and Exit point
Given two integers N and M, the task is to generate any N * M sized maze containing only 0 (representing a wall) and 1 (representing an empty space where one can move) with the entry point as P0 and exit point P1 and there is only one path between any two movable positions.
Note: P0 and P1 will be marked as 2 and 3 respectively and one can move through the moveable positions in 4 directions (up, down, right and left).
Examples:
Input: N = 5, M = 5, P0 = (0, 0), P1 = (4, 4)
Output: maze = [ [ 2 1 1 1 1 ],
[ 1 0 1 0 1 ],
[ 1 0 1 0 0 ],
[ 1 1 0 1 0 ],
[ 0 1 1 1 3 ] ]
Explanation: It is valid because there is no cycle,
and there is no unreachable walkable position.
Some other options could be
[ [ 2 1 1 1 1 ],
[ 1 0 1 0 1 ],
[ 1 0 1 0 0 ],
[ 1 1 1 1 0 ],
[ 0 0 0 1 3 ] ]
or
[ [ 2 1 1 0 1 ],
[ 1 0 1 0 1 ],
[ 1 0 1 0 0 ],
[ 1 0 1 1 0 ],
[ 1 0 0 1 3 ] ].
But these are not valid because in the first one there is a cycle in the maze
and in the second one (0, 4) and (1, 4) cannot be reached from the starting point.
Approach: The problem can be solved based on the following idea:
Use a DFS which starts from the P0 position and moves to any of the neighbours but does not make a cycle and ends at P1. In this way, there will only be 1 path between any two movable positions.
Follow the below steps to implement the idea:
- Initialize a stack (S) for the iterative DFS, the matrix that will be returned as the random maze.
- Insert the entry point P0 into the stack.
- While S is not empty, repeat the following steps:
- Remove a position (say P) from S and mark it as seen.
- If marking the position walkable, forms a cycle then don’t include it as a moveable position.
- Otherwise, set the position as walkable.
- Insert the neighbours of P which are not visited in random order into the stack.
- Random insertion in the stack guarantees that the maze being generated is random.
- If any of the neighbours is the same as the P1 then insert it at the top so that we do not skip this position because of cycle formation.
- Remove a position (say P) from S and mark it as seen.
- Mark the initial position P0 (with 2) and final position P1 (with 3)
- Return the maze.
Below is the implementation for the above approach:
Python3
# Python3 code to implement the approach from random import randint # Class to define structure of a node class Node: def __init__( self , value = None , next_element = None ): self .val = value self . next = next_element # Class to implement a stack class stack: # Constructor def __init__( self ): self .head = None self .length = 0 # Put an item on the top of the stack def insert( self , data): self .head = Node(data, self .head) self .length + = 1 # Return the top position of the stack def pop( self ): if self .length = = 0 : return None else : returned = self .head.val self .head = self .head. next self .length - = 1 return returned # Return False if the stack is empty # and true otherwise def not_empty( self ): return bool ( self .length) # Return the top position of the stack def top( self ): return self .head.val # Function to generate the random maze def random_maze_generator(r, c, P0, Pf): ROWS, COLS = r, c # Array with only walls (where paths will # be created) maze = list ( list ( 0 for _ in range (COLS)) for _ in range (ROWS)) # Auxiliary matrices to avoid cycles seen = list ( list ( False for _ in range (COLS)) for _ in range (ROWS)) previous = list ( list (( - 1 , - 1 ) for _ in range (COLS)) for _ in range (ROWS)) S = stack() # Insert initial position S.insert(P0) # Keep walking on the graph using dfs # until we have no more paths to traverse # (create) while S.not_empty(): # Remove the position of the Stack # and mark it as seen x, y = S.pop() seen[x][y] = True # Check if it will create a cycle # if the adjacent position is valid # (is in the maze) and the position # is not already marked as a path # (was traversed during the dfs) and # this position is not the one before it # in the dfs path it means that # the current position must not be marked. # This is to avoid cycles with adj positions if (x + 1 < ROWS) and maze[x + 1 ][y] = = 1 \ and previous[x][y] ! = (x + 1 , y): continue if ( 0 < x) and maze[x - 1 ][y] = = 1 \ and previous[x][y] ! = (x - 1 , y): continue if (y + 1 < COLS) and maze[x][y + 1 ] = = 1 \ and previous[x][y] ! = (x, y + 1 ): continue if (y > 0 ) and maze[x][y - 1 ] = = 1 \ and previous[x][y] ! = (x, y - 1 ): continue # Mark as walkable position maze[x][y] = 1 # Array to shuffle neighbours before # insertion to_stack = [] # Before inserting any position, # check if it is in the boundaries of # the maze # and if it were seen (to avoid cycles) # If adj position is valid and was not seen yet if (x + 1 < ROWS) and seen[x + 1 ][y] = = False : # Mark the adj position as seen seen[x + 1 ][y] = True # Memorize the position to insert the # position in the stack to_stack.append((x + 1 , y)) # Memorize the current position as its # previous position on the path previous[x + 1 ][y] = (x, y) if ( 0 < x) and seen[x - 1 ][y] = = False : # Mark the adj position as seen seen[x - 1 ][y] = True # Memorize the position to insert the # position in the stack to_stack.append((x - 1 , y)) # Memorize the current position as its # previous position on the path previous[x - 1 ][y] = (x, y) if (y + 1 < COLS) and seen[x][y + 1 ] = = False : # Mark the adj position as seen seen[x][y + 1 ] = True # Memorize the position to insert the # position in the stack to_stack.append((x, y + 1 )) # Memorize the current position as its # previous position on the path previous[x][y + 1 ] = (x, y) if (y > 0 ) and seen[x][y - 1 ] = = False : # Mark the adj position as seen seen[x][y - 1 ] = True # Memorize the position to insert the # position in the stack to_stack.append((x, y - 1 )) # Memorize the current position as its # previous position on the path previous[x][y - 1 ] = (x, y) # Indicates if Pf is a neighbour position pf_flag = False while len (to_stack): # Remove random position neighbour = to_stack.pop(randint( 0 , len (to_stack) - 1 )) # Is the final position, # remember that by marking the flag if neighbour = = Pf: pf_flag = True # Put on the top of the stack else : S.insert(neighbour) # This way, Pf will be on the top if pf_flag: S.insert(Pf) # Mark the initial position x0, y0 = P0 xf, yf = Pf maze[x0][y0] = 2 maze[xf][yf] = 3 # Return maze formed by the traversed path return maze # Driver code if __name__ = = "__main__" : N = 5 M = 5 P0 = ( 0 , 0 ) P1 = ( 4 , 4 ) maze = random_maze_generator(N, M, P0, P1) for line in maze: print (line) |
[2, 0, 0, 1, 1] [1, 1, 1, 0, 1] [0, 0, 1, 1, 1] [1, 1, 0, 0, 1] [0, 1, 1, 1, 3]
Time Complexity: O(N * M)
- As the algorithm is basically a DFS with more conditions, the time complexity is the time complexity of the DFS: O(V+E) (where V is the number of vertices and E is the number of edges).
- In this case, the number of vertices is the number of squares in the matrix: N * M. Each “vertex” (square) has at most 4 “edges” (4 adjacent squares) so E < 4*N*M. So O(V+E) will be O(5*N*M) i.e. O(N*M).
Auxiliary Space: O(N * M)
- Each auxiliary matrix needs O(N*M) of space.
- The stack can’t have more than N*M squares inside it, because it never holds (in this implementation) the same square more than one time.
- The sum of all space mentioned will be O(N*M).