Rat in a Maze with multiple steps or jump allowed?

The rat in a maze problem is a classic backtracking algorithm. In this variation, the rat can jump multiple steps instead of moving one cell at a time. The rat starts at the top-left corner M[0, 0] and must reach the bottom-right corner M[N-1, N-1]. Each cell contains a number indicating the maximum jump distance allowed from that position.

Syntax

bool ratMazeSolve(int maze[N][N], int x, int y, int sol[N][N]);

Rules

• The rat can move either towards the right or towards the down.
• Maze with 0 in cell indicates that the cell is blocked.
• Non-zero cells indicate valid paths.
• The number inside the cell indicates the maximum number of jumps the rat can make from that cell.

Algorithm

begin
   if destination is reached, then
      print the solution matrix
   else
      1. Place the current cell inside the solution matrix as 1
      2. Move forward or jump (check max jump value) and recursively check if move leads to solution or not.
      3. If the move taken from step 2 is not correct, then move down, and check it leads to the solution or not
      4. If none of the solutions in step 2 and 3 are correct, then make the current cell 0.
   end if
end

Example

Here's a complete implementation of the rat in maze problem with jump functionality −

#include <stdio.h>
#include <stdbool.h>
#define N 4

void dispSolution(int sol[N][N]) {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++)
            printf("%d ", sol[i][j]);
        printf("
");
    }
}

bool isSafe(int maze[N][N], int x, int y) {
    /* check whether x,y is valid or not */
    if (x >= 0 && x < N && y >= 0 && y < N && maze[x][y] != 0)
        return true;
    return false;
}

bool ratMazeSolve(int maze[N][N], int x, int y, int sol[N][N]) {
    if (x == N - 1 && y == N - 1) { /* if destination is found, return true */
        sol[x][y] = 1;
        return true;
    }
    if (isSafe(maze, x, y)) {
        sol[x][y] = 1; /* mark 1 into solution matrix */
        for (int i = 1; i <= maze[x][y] && i < N; i++) {
            if (ratMazeSolve(maze, x + i, y, sol)) /* move right */
                return true;
            if (ratMazeSolve(maze, x, y + i, sol)) /* move down */
                return true;
        }
        sol[x][y] = 0; /* if the solution is not valid, then make it 0 */
        return false;
    }
    return false;
}

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 (!ratMazeSolve(maze, 0, 0, sol)) {
        printf("Solution doesn't exist
");
        return false;
    }
    dispSolution(sol);
    return true;
}

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;
}

Output

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

How It Works

The algorithm uses backtracking to explore all possible paths. From each valid cell, the rat can jump 1 to maximum allowed steps either right or down. If a path leads to a dead end, the algorithm backtracks and tries alternative routes.

Conclusion

This variation of the rat in maze problem demonstrates backtracking with multiple jump options. The algorithm efficiently explores all possible paths while maintaining the constraint of maximum jumps per cell.