Random Acyclic Maze Generator with given Entry and Exit point

// JavaScript code to implement the approach

// Class to define structure of a node
class Node {
    constructor(value = null, next_element = null) {
        this.val = value;
        this.next = next_element;
    }
}

// Class to implement a stack
class Stack {
    // Constructor
    constructor() {
        this.head = null;
        this.length = 0;
    }

    // Put an item on the top of the stack
    insert(data) {
        this.head = new Node(data, this.head);
        this.length += 1;
    }

    // Return the top position of the stack
    pop() {
        if (this.length === 0) {
            return null;
        } else {
            let returned = this.head.val;
            this.head = this.head.next;
            this.length -= 1;
            return returned;
        }
    }

    // Return False if the stack is empty 
    // and true otherwise
    not_empty() {
        return Boolean(this.length);
    }

    // Return the top position of the stack
    top() {
        return this.head.val;
    }
}

// Function to generate the random maze
function random_maze_generator(r, c, P0, Pf) {
    const ROWS = r;
    const COLS = c;
    // Array with only walls (where paths will 
    // be created)
    const maze = [...Array(ROWS)].map(() => Array(COLS).fill(0));

    // Auxiliary matrices to avoid cycles
    const seen = [...Array(ROWS)].map(() => Array(COLS).fill(false));
    const previous = [...Array(ROWS)].map(() => Array(COLS).fill([-1, -1]));
    const S = [];

    // Insert initial position
    S.push(P0);

    // Keep walking on the graph using dfs
    // until we have no more paths to traverse 
    // (create)
    while (S.length > 0) {
        // Remove the position of the Stack
        // and mark it as seen
        const [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 && maze[x + 1][y] === 1 && !isEqual(previous[x][y], [x + 1, y])) continue;
        if (x > 0 && maze[x - 1][y] === 1 && !isEqual(previous[x][y], [x - 1, y])) continue;
        if (y + 1 < COLS && maze[x][y + 1] === 1 && !isEqual(previous[x][y], [x, y + 1])) continue;
        if (y > 0 && maze[x][y - 1] === 1 && !isEqual(previous[x][y], [x, y - 1])) continue;

        // Mark as walkable position
        maze[x][y] = 1;
        // Array to shuffle neighbours before 
        // insertion
        const 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 && !seen[x + 1][y]) {
            // Mark the adj position as seen
            seen[x + 1][y] = true;
            // Memorize the position to insert the 
            // position in the stack
            to_stack.push([x + 1, y]);
            // Memorize the current position as its 
            // previous position on the path
            previous[x + 1][y] = [x, y];
        }

        if (x > 0 && !seen[x - 1][y]) {
            // Mark the adj position as seen
            seen[x - 1][y] = true;

            // Memorize the position to insert the 
            // position in the stack
            to_stack.push([x - 1, y]);

            // Memorize the current position as its 
            // previous position on the path
            previous[x - 1][y] = [x, y];
        }

        if (y + 1 < COLS && !seen[x][y + 1]) {
            // Mark the adj position as seen
            seen[x][y + 1] = true;
            // Memorize the position to insert the 
            // position in the stack
            to_stack.push([x, y + 1]);
            // Memorize the current position as its
            // previous position on the path
            previous[x][y + 1] = [x, y];
        }

        if (y > 0 && !seen[x][y - 1]) {
            // Mark the adj position as seen
            seen[x][y - 1] = true;
            // Memorize the position to insert the 
            // position in the stack
            to_stack.push([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
        let pf_flag = false;

        while (to_stack.length > 0) {
            const index = Math.floor(Math.random() * to_stack.length);
            const neighbour = to_stack.splice(index, 1)[0];

            // Is the final position, 
            // remember that by marking the flag
            if (isEqual(neighbour, Pf)) {
                pf_flag = true;
            } else {
                // Put on the top of the stack

                S.push(neighbour);
            }
        }

        // This way, Pf will be on the top 
        if (pf_flag) {
            S.push(Pf);
        }
    }

    // Mark the initial position
    const [x0, y0] = P0;
    const [xf, yf] = Pf;
    maze[x0][y0] = 2;
    maze[xf][yf] = 3;

    // Return maze formed by the traversed path
    return maze;
}

// Helper function to compare two arrays for equality
function isEqual(arr1, arr2) {
    return arr1[0] === arr2[0] && arr1[1] === arr2[1];
}

// Driver code
const N = 5;
const M = 5;
const P0 = [0, 0];
const P1 = [4, 4];
const maze = random_maze_generator(N, M, P0, P1);
for (const line of maze) {
    console.log(line);
}

// Contributed by adityasharmadev01