Maze Problem - Backtracking

A Maze is given as N*N binary matrix of blocks where source block is the upper left most block i.e., maze[0][0] and destination block is lower rightmost block i.e., maze[N-1][N-1]. 
A rat starts from source and has to reach destination. The rat can move only in two directions: forward and down.
In the maze matrix, 0 means the block is dead end and 1 means the block can be used in the path from source to destination.

Find the path that rat should take from source to destination.





/* Java program to solve Rat in a Maze problem using
backtracking */

public class Maze {

    final int N = 4;

    /*
     * A utility function to print solution matrix sol[N][N]
     */
    void printSolution(int sol[][]) {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                System.out.print(" " + sol[i][j] + " ");
            }
            System.out.println();
        }
    }

    /*
     * A utility function to check if x,y is valid index for N*N maze
     */
    boolean isSafe(int maze[][], int x, int y) {
        // if (x,y outside maze) return false
        return (x >= 0 && x < N && y >= 0 && y < N && maze[x][y] == 1);
    }

    /*
     * This function solves the Maze problem using Backtracking. It mainly uses
     * solveMazeUtil() to solve the problem. It returns false if no path is
     * possible, otherwise return true and prints the path in the form of 1s.
     * Please note that there may be more than one solutions, this function
     * prints one of the feasible solutions.
     */
    boolean solveMaze(int maze[][]) {
        int sol[][] = { { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 } };

        if (solve(maze, 0, 0, sol) == false) {
            System.out.print("Solution doesn't exist");
            return false;
        }

        printSolution(sol);
        return true;
    }

    /*
     * A recursive utility function to solve Maze problem
     */
    boolean solve(int maze[][], int x, int y, int sol[][]) {
        // if (x,y is goal) return true
        if (x == N - 1 && y == N - 1) {
            sol[x][y] = 1;
            return true;
        }

        // Check if maze[x][y] is valid
        if (isSafe(maze, x, y) == true) {
            // mark x,y as part of solution path
            sol[x][y] = 1;

            /* Move forward in x direction */
            if (solve(maze, x + 1, y, sol)) {
                return true;
            }

            /*
             * If moving in x direction doesn't give solution then Move down in
             * y direction
             */
            if (solve(maze, x, y + 1, sol)) {
                return true;
            }

            /*
             * If none of the above movements work then BACKTRACK: unmark x,y as
             * part of solution path
             */
            sol[x][y] = 0;
            return false;
        }

        return false;
    }

    public static void main(String args[]) {
        Maze rat = new Maze();
        int maze[][] = { { 1, 0, 0, 0 }, { 1, 1, 0, 1 }, { 0, 1, 0, 0 }, { 1, 1, 1, 1 } };
        rat.solveMaze(maze);
    }
}

Comments

Popular posts from this blog

Java important topics list for interviews

Tough Sql practise questions for interviews involving SELECT queries - Part 2

DBMS important topics list for interviews

Program to find number lines and words in a given file

Tough Sql practise questions for interviews involving SELECT queries - Part 1

Producer Consumer Problem with Blocking Queue in Java.

Animation for String search - KMP Algorithm

Interactive Data Structure visualizations/animations for algorithms

Replace Occurances of the given string