 Open in App
Not now

# Rat in a Maze with multiple steps or jump allowed

• Difficulty Level : Medium
• Last Updated : 08 Aug, 2022

This is the variation of Rat in Maze

A Maze is given as N*N binary matrix of blocks where source block is the upper left most block i.e., maze 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 non-zero number means the block can be used in the path from source to destination. The non-zero value of mat[i][j] indicates number of maximum jumps rat can make from cell mat[i][j].

In this variation, Rat is allowed to jump multiple steps at a time instead of 1.

Examples:

```Input : { {2, 1, 0, 0},
{3, 0, 0, 1},
{0, 1, 0, 1},
{0, 0, 0, 1}
}
Output : { {1, 0, 0, 0},
{1, 0, 0, 1},
{0, 0, 0, 1},
{0, 0, 0, 1}
}

Explanation
Rat started with M and can jump upto 2 steps right/down.
Let's try in horizontal direction -
M won't lead to solution and M is 0 which is dead end.
So, backtrack and try in down direction.
Rat jump down to M which eventually leads to solution.

Input : {
{2, 1, 0, 0},
{2, 0, 0, 1},
{0, 1, 0, 1},
{0, 0, 0, 1}
}
Output : Solution doesn't exist```

Naive Algorithm:

The Naive Algorithm is to generate all paths from source to destination and one by one check if the generated path satisfies the constraints.

```while there are untried paths
{
generate the next path
if this path has all blocks as non-zero
{
print this path;
}
}```

Backtracking Algorithm:

```If destination is reached
print the solution matrix
Else
a) Mark current cell in solution matrix as 1.
b) Move forward/jump (for each valid steps) in horizontal direction
and recursively check if this move leads to a solution.
c) If the move chosen in the above step doesn't lead to a solution
then move down and check if this move leads to a solution.
d) If none of the above solutions work then unmark this cell as 0
(BACKTRACK) and return false.```

Implementation of Backtracking solution

## C++

 `/* C/C++ program to solve Rat in a Maze problem ` `using backtracking */` `#include `   `// Maze size ` `#define N 4 `   `bool` `solveMazeUtil(``int` `maze[N][N], ``int` `x, ``int` `y, ` `                                ``int` `sol[N][N]); `   `/* A utility function to print solution matrix ` `sol[N][N] */` `void` `printSolution(``int` `sol[N][N]) ` `{ ` `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``for` `(``int` `j = 0; j < N; j++) ` `            ``printf``(``" %d "``, sol[i][j]); ` `        ``printf``(``"\n"``); ` `    ``} ` `} `   `/* A utility function to check if x, y is valid ` `index for N*N maze */` `bool` `isSafe(``int` `maze[N][N], ``int` `x, ``int` `y) ` `{ ` `    ``// if (x, y outside maze) return false ` `    ``if` `(x >= 0 && x < N && y >= 0 && ` `    ``y < N && maze[x][y] != 0) ` `        ``return` `true``; `   `    ``return` `false``; ` `} `   `/* 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.*/` `bool` `solveMaze(``int` `maze[N][N]) ` `{ ` `    ``int` `sol[N][N] = { { 0, 0, 0, 0 }, ` `                    ``{ 0, 0, 0, 0 }, ` `                    ``{ 0, 0, 0, 0 }, ` `                    ``{ 0, 0, 0, 0 } }; `   `    ``if` `(solveMazeUtil(maze, 0, 0, sol) == ``false``) { ` `        ``printf``(``"Solution doesn't exist"``); ` `        ``return` `false``; ` `    ``} `   `    ``printSolution(sol); ` `    ``return` `true``; ` `} `   `/* A recursive utility function to solve Maze problem */` `bool` `solveMazeUtil(``int` `maze[N][N], ``int` `x, ``int` `y, ` `                                ``int` `sol[N][N]) ` `{ ` `    ``// 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 */` `        ``for` `(``int` `i = 1; i <= maze[x][y] && i < N; i++) { `   `            ``/* Move forward in x direction */` `            ``if` `(solveMazeUtil(maze, x + i, y, sol) == ``true``) ` `                ``return` `true``; `   `            ``/* If moving in x direction doesn't give ` `            ``solution then Move down in y direction */` `            ``if` `(solveMazeUtil(maze, x, y + i, sol) == ``true``) ` `                ``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``; ` `} `   `// driver program to test above function ` `int` `main() ` `{ ` `    ``int` `maze[N][N] = { { 2, 1, 0, 0 }, ` `                    ``{ 3, 0, 0, 1 }, ` `                    ``{ 0, 1, 0, 1 }, ` `                    ``{ 0, 0, 0, 1 } }; `   `    ``solveMaze(maze); ` `    ``return` `0; ` `} `

## Java

 `// Java program to solve Rat in a Maze problem ` `// using backtracking` `class` `GFG ` `{`   `    ``// Maze size ` `    ``static` `int` `N = ``4``;`   `    ``/* A utility function to print solution matrix ` `    ``sol[N][N] */` `    ``static` `void` `printSolution(``int` `sol[][]) ` `    ``{` `        ``for` `(``int` `i = ``0``; i < N; i++)` `        ``{` `            ``for` `(``int` `j = ``0``; j < N; j++) ` `            ``{` `                ``System.out.printf(``" %d "``, sol[i][j]);` `            ``}` `            ``System.out.printf(``"\n"``);` `        ``}` `    ``}`   `    ``/* A utility function to check if x, y is valid ` `    ``index for N*N maze */` `    ``static` `boolean` `isSafe(``int` `maze[][], ``int` `x, ``int` `y) ` `    ``{` `        `  `        ``// if (x, y outside maze) return false ` `        ``if` `(x >= ``0` `&& x < N && y >= ``0` `&& ` `             ``y < N && maze[x][y] != ``0``)` `        ``{` `            ``return` `true``;` `        ``}`   `        ``return` `false``;` `    ``}`   `    ``/* 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.*/` `    ``static` `boolean` `solveMaze(``int` `maze[][]) ` `    ``{` `        ``int` `sol[][] = {{``0``, ``0``, ``0``, ``0``},` `                       ``{``0``, ``0``, ``0``, ``0``},` `                       ``{``0``, ``0``, ``0``, ``0``},` `                       ``{``0``, ``0``, ``0``, ``0``}};`   `        ``if` `(solveMazeUtil(maze, ``0``, ``0``, sol) == ``false``) ` `        ``{` `            ``System.out.printf(``"Solution doesn't exist"``);` `            ``return` `false``;` `        ``}`   `        ``printSolution(sol);` `        ``return` `true``;` `    ``}`   `    ``/* A recursive utility function to solve Maze problem */` `    ``static` `boolean` `solveMazeUtil(``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 */` `            ``for` `(``int` `i = ``1``; i <= maze[x][y] && i < N; i++) ` `            ``{`   `                ``/* Move forward in x direction */` `                ``if` `(solveMazeUtil(maze, x + i, y, sol) == ``true``) ` `                ``{` `                    ``return` `true``;` `                ``}`   `                ``/* If moving in x direction doesn't give ` `                ``solution then Move down in y direction */` `                ``if` `(solveMazeUtil(maze, x, y + i, sol) == ``true``) ` `                ``{` `                    ``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``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `maze[][] = {{``2``, ``1``, ``0``, ``0``},` `                        ``{``3``, ``0``, ``0``, ``1``},` `                        ``{``0``, ``1``, ``0``, ``1``},` `                        ``{``0``, ``0``, ``0``, ``1``}};`   `        ``solveMaze(maze);` `    ``}` `}`   `// This code is contributed by Princi Singh`

## Python3

 `""" Python3 program to solve Rat in a` `Maze problem using backtracking """`   `# Maze size ` `N ``=` `4`   `""" A utility function to print solution matrix ` `sol """` `def` `printSolution(sol):` `    ``for` `i ``in` `range``(N):` `        ``for` `j ``in` `range``(N):` `            ``print``(sol[i][j], end ``=` `" "``)` `        ``print``() ` `        `  `""" A utility function to check if ` `x, y is valid index for N*N maze """` `def` `isSafe(maze, x, y):` `    `  `    ``# if (x, y outside maze) return false ` `    ``if` `(x >``=` `0` `and` `x < N ``and` `y >``=` `0` `and` `         ``y < N ``and` `maze[x][y] !``=` `0``):` `        ``return` `True` `    ``return` `False`   `""" 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."""` `def` `solveMaze(maze):` `    ``sol ``=` `[[``0``, ``0``, ``0``, ``0``],` `           ``[``0``, ``0``, ``0``, ``0``],` `           ``[``0``, ``0``, ``0``, ``0``],` `           ``[``0``, ``0``, ``0``, ``0``]]` `    ``if` `(solveMazeUtil(maze, ``0``, ``0``, sol) ``=``=` `False``):` `        ``print``(``"Solution doesn't exist"``)` `        ``return` `False` `    ``printSolution(sol)` `    ``return` `True` `    `  `""" A recursive utility function ` `to solve Maze problem """` `def` `solveMazeUtil(maze, x, y, sol):` `    `  `    ``# if (x, y is goal) return True ` `    ``if` `(x ``=``=` `N ``-` `1` `and` `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 """` `        ``for` `i ``in` `range``(``1``, N):` `            ``if` `(i <``=` `maze[x][y]):` `                `  `                ``""" Move forward in x direction """` `                ``if` `(solveMazeUtil(maze, x ``+` `i, ` `                                  ``y, sol) ``=``=` `True``): ` `                    ``return` `True` `                    `  `                ``""" If moving in x direction doesn't give ` `                ``solution then Move down in y direction """` `                ``if` `(solveMazeUtil(maze, x, ` `                                  ``y ``+` `i, sol) ``=``=` `True``):` `                    ``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`   `# Driver Code` `maze ``=` `[[``2``, ``1``, ``0``, ``0``],` `        ``[``3``, ``0``, ``0``, ``1``],` `        ``[``0``, ``1``, ``0``, ``1``],` `        ``[``0``, ``0``, ``0``, ``1``]]` `solveMaze(maze) `   `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# program to solve Rat in a Maze problem ` `// using backtracking` `using` `System;` `    `  `class` `GFG ` `{`   `    ``// Maze size ` `    ``static` `int` `N = 4;`   `    ``/* A utility function to print ` `    ``solution matrix sol[N, N] */` `    ``static` `void` `printSolution(``int` `[,]sol) ` `    ``{` `        ``for` `(``int` `i = 0; i < N; i++)` `        ``{` `            ``for` `(``int` `j = 0; j < N; j++) ` `            ``{` `                ``Console.Write(``" {0} "``, sol[i, j]);` `            ``}` `            ``Console.Write(``"\n"``);` `        ``}` `    ``}`   `    ``/* A utility function to check if` `    ``x, y is valid index for N*N maze */` `    ``static` `Boolean isSafe(``int` `[,]maze,` `                          ``int` `x, ``int` `y) ` `    ``{` `        `  `        ``// if (x, y outside maze) return false ` `        ``if` `(x >= 0 && x < N && y >= 0 && ` `            ``y < N && maze[x, y] != 0)` `        ``{` `            ``return` `true``;` `        ``}`   `        ``return` `false``;` `    ``}`   `    ``/* 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.*/` `    ``static` `Boolean solveMaze(``int` `[,]maze) ` `    ``{` `        ``int` `[,]sol = {{0, 0, 0, 0},` `                      ``{0, 0, 0, 0},` `                      ``{0, 0, 0, 0},` `                      ``{0, 0, 0, 0}};`   `        ``if` `(solveMazeUtil(maze, 0, 0, sol) == ``false``) ` `        ``{` `            ``Console.Write(``"Solution doesn't exist"``);` `            ``return` `false``;` `        ``}`   `        ``printSolution(sol);` `        ``return` `true``;` `    ``}`   `    ``/* A recursive utility function to solve Maze problem */` `    ``static` `Boolean solveMazeUtil(``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 */` `            ``for` `(``int` `i = 1;` `                     ``i <= maze[x, y] && i < N; i++) ` `            ``{`   `                ``/* Move forward in x direction */` `                ``if` `(solveMazeUtil(maze, x + i, ` `                                  ``y, sol) == ``true``) ` `                ``{` `                    ``return` `true``;` `                ``}`   `                ``/* If moving in x direction doesn't give ` `                ``solution then Move down in y direction */` `                ``if` `(solveMazeUtil(maze, x,` `                                  ``y + i, sol) == ``true``) ` `                ``{` `                    ``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``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int` `[,]maze = {{2, 1, 0, 0},` `                       ``{3, 0, 0, 1},` `                       ``{0, 1, 0, 1},` `                       ``{0, 0, 0, 1}};`   `        ``solveMaze(maze);` `    ``}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

```1  0  0  0
1  0  0  1
0  0  0  1
0  0  0  1```

My Personal Notes arrow_drop_up
Related Articles