Python Tutorial

In this tutorial, we learn about random Acyclic Maze Generator with given Entry and Exit points using Python. Here, we need to take two integer values, A and B. The main task is creating a maze containing size A * B with only 0 and 1 with entry point P0 and exit point P1. 0 represents a wall, and 1 represents the free space that can be moved. Between any two movable positions must contain a path. P0 is marked as 2, and P1 is marked as 3. It can move in 4 directions (up, down, right, left) moving position.

Example:

Now, we give an example of a random Acyclic Maze Generator with a given Entry and Exit point by taking an input and sharing its output. So, the example is now given in below -

Input: 
A = 6, B = 6, P0 = (0, 1), P1 = (5, 5)
Output: 
maze = [ [0 2 1 0 1 1]
                [1 0 1 1 0 1]
                [1 1 0 1 0 1]
                [1 0 0 1 1 1]
                [1 1 1 0 0 1]
                [1 0 1 1 1 3]]


Explanation: 
It works because there are no walkable positions that are unreachable.
There could be some options, that is shared below: 
[ [0 2 1 0 1 1]
  [1 0 1 1 0 1]
  [1 1 0 1 0 1]
  [1 0 0 1 1 1]
  [1 1 1 0 1 1]
  [1 1 1 1 1 3]]
or
[ [0 2 1 1 1 1]
   [1 0 1 1 1 1]
   [1 1 0 1 0 1]
   [1 0 0 1 1 1]
   [1 0 1 0 0 1]
   [1 0 1 1 1 3]]

Algorithm:

Now we learn about the algorithm of random Acyclic Maze Generator with given Entry and Exit point using Python. The steps are given in below -

For the iterative DFS, stack (S) is initialized. The matrix returns the random maze.
P0 is the entry point. It is inserted into the stack.
Repeat the following steps until the stack is not empty:
1. Remove the position from stack (S). Then mark it as seen.
2. If the position marker is walkable, create a loop and exclude it as a moveable position. Otherwise, it sets the position as walkable.
3. Put the unvisited neighbours in P into the stack in random order.
4. Random insertion into the stack ensures that the generated maze is random.
5. If a neighbour is similar to P1, then insert this neighbour at the top of the stack. For that, we do not skip this position because of the loop creation.
P0 is marked by 2, which is the initial position of the stack. P1 is marked by 3, which is the final position.
Lastly, the maze is returned.

Program code:

Here, we use Python to give the program code of a random Acyclic Maze Generator with given Entry and Exit points. The code is now given below -

from random import randint
# Define the node class for implementing the Node
class Node:
    def __init__(self, value = None, next_element = None):
        self.val = value
        self.next = next_element
 
# Define the stack class for implementing stack
class stack:
   
    # Initialize the constructor
    def __init__(self):
        self.head = None
        self.length = 0
 
    # Define the function insert_stack, which is used to insert into the stack
    def insert_stack(self, data):
        self.head = Node(data, self.head)
        self.length += 1
 
    # Define the function pop_stack, which returns the stack's top position
    def pop_stack(self):
        if self.length == 0:
            return None
        else:
            returned = self.head.val
            self.head = self.head.next
            self.length -= 1
            return returned
 
    # If the stack is full, then it returns true. Otherwise, it returns false 
    def not_empty(self):
        return bool(self.length)
 
    # Return the top position of the stack
    def top(self):
        return self.head.val
 
# Define the function random_maze_generator
def random_maze_generator(R, C, P0, Pf):
    ROW, COL = R, C
    maze = list(list(0 for _ in range(COL))
                       for _ in range(ROW))
    seen = list(list(False for _ in range(COL))
                           for _ in range(ROW))
    previous = list(list((-1, -1)
     for _ in range(COL)) for _ in range(ROW))
 
    S = stack()
    S.insert_stack(P0)
    while S.not_empty():
 
        # Here, the stack position is removed and marked as seen
        m, n = S.pop_stack()
        seen[m][n] = True
 
        # Check if it will create a cycle or not

        if (m + 1 < ROW) and maze[m + 1][n] == 1 \
        and previous[m][n] != (m + 1,  n):
            continue
        if (0 < m) and maze[m-1][n] == 1 \
        and previous[m][n] != (m-1,  n):
            continue
        if (n + 1 < COL) and maze[m][n + 1] == 1 \
        and previous[m][n] != (m, n + 1):
            continue
        if (n > 0) and maze[m][n-1] == 1 \
        and previous[m][n] != (m, n-1):
            continue
 
        # Mark as a walkable position
        maze[m][n] = 1
        to_stack = []
 
        if (m + 1 < ROW) and seen[m + 1][n] == False:
             
            # adj position marked as seen
            seen[m + 1][n] = True
             
            to_stack.append((m + 1,  n))
             
            # Memorize the current position 
            previous[m + 1][n] = (m, n)
         
        if (0 < m) and seen[m-1][n] == False:
             
            # Mark the adj position as seen
            seen[m-1][n] = True
            to_stack.append((m-1,  n))
            previous[m-1][n] = (m, n)
         
        if (n + 1 < COL) and seen[m][n + 1] == False:
             
            # Mark the adj position as seen
            seen[m][n + 1] = True
             
            # Memorize the position to insert 
            to_stack.append((m, n + 1))
             
            # The current position is to memorize
            previous[m][n + 1] = (m, n)
         
        if (n > 0) and seen[m][n-1] == False:
             
            # adj position marked as seen
            seen[m][n-1] = True
            to_stack.append((m, n-1))
            previous[m][n-1] = (m, n)
        pf_flag = False
        while len(to_stack):
             
            # Here, random position is removed
            neighbour = to_stack.pop(randint(0, len(to_stack)-1))
            if neighbour == Pf:
                pf_flag = True
             
            else:
                S.insert_stack(neighbour)

        if pf_flag:
            S.insert_stack(Pf)
                 
    # Initial position initialized here
    m0, n0 = P0
    mf, nf = Pf
    maze[m0][n0] = 3
    maze[mf][nf] = 4
     
    # Return the maze formed by the traversed path
    return maze
 
# Write the main function and initialize the value of B, A, P0, and P1
if __name__ == "__main__":
    B = 6
    A = 6
    P0 = (0, 1)
    P1 = (5, 5)
    maze = random_maze_generator(B, A, P0, P1)
    for line in maze:
        print(line)

Output:

Now, we compile the above code in Python, and after successful compilation, we run it. The output is given below -

[1, 3, 1, 0, 1, 1]
[1, 0, 1, 1, 1, 0]
[0, 1, 0, 0, 1, 1]
[1, 1, 1, 0, 1, 0]
[1, 0, 0, 1, 1, 1]
[1, 1, 1, 1, 0, 4]

Next TopicSolving Linear Equations with Python

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

^{Like/Subscribe us for latest updates or newsletter}

Python Tutorial

Python OOPs

Python MySQL

Python MongoDB

Python SQLite

Python Questions

Plotly

Python Tkinter (GUI)

Python Web Blocker

Python MCQ

Related Tutorials

Python Programs

Random Acyclic Maze Generator with given Entry and Exit point using Python