# A variation of Rat in a Maze : multiple steps or jumps allowed

A variation of rat in a maze.

You are given an **N * N** 2-D matrix shaped maze (let’s call it M), there is a rat in the **top-left cell** i.e. **M[0][0]** and there is an escape door in the **bottom-right cell** i.e. **M[N-1][N-1]**. From each cell **M[i][j]** (0 ≤ i ≤ N-1, 0 ≤ j ≤ N-1) the rat can go a number of steps towards its right ( for eg: to M[i][j+ s]), or a number of steps downwards ( for eg: to M[i+ s][j]), where the maximum number of steps (or maximum value of s) can be the value in the cell **M[i][j]**. If any cell contains **0** then that is a **dead-end**. **For eg:** In the second picture in the figure below, the rat at **M[0][0]** can jump to a cell : **M[0][1]**, **M[0][2]**, **M[1][0]** or **M[2][0]**.

You have to print a possible path **from M[0][0] to M[N-1][N-1]** in the form of a matrix of size **N * N** such that the cells that are in the path have a value **1** and other cells have a value **0**. For the above example one such solution is :

There is a **backtracking solution** for this problem in this article.

**Here a Dynamic Programming based solution is presented.**

**Examples:**

Input:mat[][] = {

{3, 0, 0, 2, 1},

{0, 0, 0, 0, 2},

{0, 1, 0, 1, 0},

{1, 0, 0, 1, 1},

{3, 0, 0, 1, 1} }

Output:

1 0 0 1 1

0 0 0 0 1

0 0 0 0 0

0 0 0 0 1

0 0 0 0 1

Input:mat[][] = { {0, 0}, {0, 1} }

Output:No path exists

**Approach:**

- Initialize a boolean
**CRF[N][N]**(can reach from) matrix with**false**. Now make**CRF[N – 1][N – 1] = true**as destination can be reached from the destination. - Now, starting from
**maze[N – 1][N – 1]**and ending at**maze[0][0]**update all the cells in**CRF[][]**according to whether it is possible to reach any other valid cell (leading to the destination). - When all of the
**CRF[][]**matrix has been updated, use to create a matrix which contains all**1s**at the cells in the path leading to the destination and other cells are**0s**. - Print this newly created matrix in the end.
- If it is not possible to reach the destination then print
**No path exists**.

Below is the implementation of the above approach:

`// C++ implementation of the approach ` `#include <iostream> ` `using` `namespace` `std; ` `#define MAX 50 ` ` ` `// Function to check whether the path exists ` `bool` `hasPath(` `int` `maze[][MAX], ` `int` `sol[][MAX], ` ` ` `int` `N) ` `{ ` ` ` ` ` `for` `(` `int` `i = 0; i < N; i++) ` ` ` `for` `(` `int` `j = 0; j < N; j++) ` ` ` `sol[i][j] = 0; ` ` ` ` ` `// Declaring and initializing CRF ` ` ` `// (can reach from) matrix ` ` ` `bool` `** CRF = ` `new` `bool` `*[N]; ` ` ` `for` `(` `int` `i = 0; i < N; i++) ` ` ` `CRF[i] = ` `new` `bool` `[N]; ` ` ` ` ` `for` `(` `int` `i = 0; i < N; i++) ` ` ` `for` `(` `int` `j = 0; j < N; j++) ` ` ` `CRF[i][j] = ` `false` `; ` ` ` `CRF[N - 1][N - 1] = ` `true` `; ` ` ` ` ` `// Using the DP to fill CRF matrix ` ` ` `// in correct order ` ` ` `for` `(` `int` `k = N - 1; k >= 0; k--) { ` ` ` `for` `(` `int` `j = k; j >= 0; j--) { ` ` ` ` ` `if` `(!(k == N - 1 && j == N - 1)) { ` ` ` ` ` `// If it is possible to get ` ` ` `// to a valid location from ` ` ` `// cell maze[k][j] ` ` ` `for` `(` `int` `a = 0; a <= maze[k][j]; a++) { ` ` ` `if` `((j + a < N && CRF[k][j + a] == ` `true` `) ` ` ` `|| (k + a < N && CRF[k + a][j] == ` `true` `)) { ` ` ` `CRF[k][j] = ` `true` `; ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `// If it is possible to get to ` ` ` `// a valid location from cell ` ` ` `// maze[j][k] ` ` ` `for` `(` `int` `a = 0; a <= maze[j][k]; a++) { ` ` ` `if` `((k + a < N && CRF[j][k + a] == ` `true` `) ` ` ` `|| (j + a < N && CRF[j + a][k] == ` `true` `)) { ` ` ` `CRF[j][k] = ` `true` `; ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` ` ` `// If CRF[0][0] is false it means we cannot reach ` ` ` `// the end of the maze at all ` ` ` `if` `(CRF[0][0] == ` `false` `) ` ` ` `return` `false` `; ` ` ` ` ` `// Filling the solution matrix using CRF ` ` ` `int` `i = 0, j = 0; ` ` ` `while` `(!(i == N - 1 && j == N - 1)) { ` ` ` `sol[i][j] = 1; ` ` ` `if` `(maze[i][j] > 0) ` ` ` ` ` `// Get to a valid location from ` ` ` `// the current cell ` ` ` `for` `(` `int` `a = 1; a <= maze[i][j]; a++) { ` ` ` `if` `((j + a < N && CRF[i][j + a] == ` `true` `)) { ` ` ` `j = j + a; ` ` ` `break` `; ` ` ` `} ` ` ` `else` `if` `((i + a < N && CRF[i + a][j] == ` `true` `)) { ` ` ` `i = i + a; ` ` ` `break` `; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` `sol[N - 1][N - 1] = 1; ` ` ` ` ` `return` `true` `; ` `} ` ` ` `// Utility function to print the contents ` `// of a 2-D array ` `void` `printMatrix(` `int` `sol[][MAX], ` `int` `N) ` `{ ` ` ` `for` `(` `int` `i = 0; i < N; i++) { ` ` ` `for` `(` `int` `j = 0; j < N; j++) ` ` ` `cout << sol[i][j] << ` `" "` `; ` ` ` `cout << ` `"\n"` `; ` ` ` `} ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` ` ` `int` `maze[][MAX] = { { 2, 2, 1, 1, 0 }, ` ` ` `{ 0, 0, 3, 0, 0 }, ` ` ` `{ 1, 0, 0, 0, 0 }, ` ` ` `{ 0, 0, 2, 0, 1 }, ` ` ` `{ 0, 0, 3, 0, 0 } }; ` ` ` `int` `N = ` `sizeof` `(maze) / ` `sizeof` `(maze[0]); ` ` ` `int` `sol[N][MAX]; ` ` ` ` ` `// If path exists ` ` ` `if` `(hasPath(maze, sol, N)) ` ` ` ` ` `// Print the path ` ` ` `printMatrix(sol, N); ` ` ` `else` ` ` `cout << ` `"No path exists"` `; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1

## Recommended Posts:

- Rat in a Maze with multiple steps or jump allowed
- Traversal of tree with k jumps allowed between nodes of same height
- Rat in a Maze | Backtracking-2
- Rat in a Maze | Backtracking using Stack
- Shortest path in a Binary Maze
- Count number of ways to reach destination in a Maze
- Minimum number of jumps to reach end
- Reach the numbers by making jumps of two given lengths
- Minimum jumps to reach last building in a matrix
- Minimum number of jumps to reach end | Set 2 (O(n) solution)
- Source to destination in 2-D path with fixed sized jumps
- Check if it is possible to reach a number by making jumps of two given length
- Maximum path sum for each position with jumps under divisibility condition
- Minimum cells traversed to reach corner where every cell represents jumps
- Minimum cells required to reach destination with jumps equal to cell values

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.