Rat in a Maze - Problem

A rat is placed at position (0, 0) in an N x N maze. The rat needs to find all possible paths to reach the destination at (N-1, N-1).

The rat can only move in two directions:

Right (R): from (i, j) to (i, j+1)
Down (D): from (i, j) to (i+1, j)

The maze is represented by a 2D array where 1 indicates an open path and 0 indicates a blocked wall. The rat can only move through cells containing 1.

Return all possible paths as a list of strings, where each string represents a path using characters 'R' (right) and 'D' (down). If no path exists, return an empty list.

Input & Output

Example 1 — Basic 3x3 Maze

$ Input: maze = [[1,1,1],[1,0,1],[1,1,1]]

› Output: ["RRDD","RDRD","DRRD","DDRR"]

💡 Note: Four valid paths exist: going right-right-down-down, right-down-right-down, down-right-right-down, and down-down-right-right. The middle cell (1,1) is blocked.

Example 2 — Single Path

$ Input: maze = [[1,0],[1,1]]

› Output: ["DR"]

💡 Note: Only one path possible: down from (0,0) to (1,0), then right to destination (1,1). Cannot go right first due to blocked cell.

Example 3 — No Path Available

$ Input: maze = [[1,0],[0,1]]

› Output: []

💡 Note: No path exists because both adjacent cells from start (0,0) are blocked, making destination unreachable.

Constraints

1 ≤ maze.length ≤ 10
maze[i][j] is 0 or 1
maze[0][0] = 1 (start is always open)

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is using backtracking to systematically explore all valid paths while avoiding revisits. The optimal approach uses recursive exploration with proper cleanup, ensuring all possible routes from start to destination are found. Time: O(2^(m+n)), Space: O(m+n)

Common Approaches

✓ Optimized Backtracking

⏱️ Time: O(2^(m+n)) Space: O(m+n)

Enhance the recursive approach with backtracking principles. Mark visited cells to avoid revisiting, and systematically explore all valid directions with proper cleanup.

Recursive Path Generation

⏱️ Time: O(2^(m+n)) Space: O(m+n)

Use recursion to explore every possible path from (0,0) to (n-1,n-1). At each cell, try both right and down moves if valid, building the path string as we go.

Optimized Backtracking — Algorithm Steps

Mark current cell as visited in a tracking array
If destination reached, record the path
Try all valid moves (right, down) recursively
Backtrack by unmarking current cell for other paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Mark Visited

Mark current cell as visited

Try Moves

Explore valid right and down moves

Recurse

Continue path from new position

Backtrack

Unmark visited to allow other paths

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#define MAX_SIZE 10
#define MAX_PATHS 1000
#define MAX_PATH_LEN 20

char paths[MAX_PATHS][MAX_PATH_LEN];
int path_count = 0;
bool visited[MAX_SIZE][MAX_SIZE];

void backtrack(int maze[MAX_SIZE][MAX_SIZE], int n, int i, int j, char* path, int path_len) {
    if (i == n-1 && j == n-1) {
        path[path_len] = '\0';
        strcpy(paths[path_count], path);
        path_count++;
        return;
    }
    
    visited[i][j] = true;
    
    // Try all directions: Right, Down
    int di[] = {0, 1};
    int dj[] = {1, 0};
    char moves[] = {'R', 'D'};
    
    for (int d = 0; d < 2; d++) {
        int ni = i + di[d];
        int nj = j + dj[d];
        
        if (ni >= 0 && ni < n && nj >= 0 && nj < n &&
            maze[ni][nj] == 1 && !visited[ni][nj]) {
            path[path_len] = moves[d];
            backtrack(maze, n, ni, nj, path, path_len + 1);
        }
    }
    
    visited[i][j] = false;  // Backtrack
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Initialize visited array
    memset(visited, false, sizeof(visited));
    
    // Simple parsing for small matrices
    int maze[MAX_SIZE][MAX_SIZE];
    int n = 0;
    
    // Count matrix size (count opening brackets)
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && line[i-1] != '[') n++;
    }
    n--; // Subtract outer bracket
    
    // Parse matrix values
    char* ptr = line + 1; // Skip first [
    for (int i = 0; i < n; i++) {
        ptr = strchr(ptr, '[') + 1;
        for (int j = 0; j < n; j++) {
            maze[i][j] = strtol(ptr, &ptr, 10);
            while (*ptr == ',' || *ptr == ' ') ptr++;
        }
    }
    
    path_count = 0;
    if (maze[0][0] == 1) {
        char path[MAX_PATH_LEN];
        backtrack(maze, n, 0, 0, path, 0);
    }
    
    printf("[");
    for (int i = 0; i < path_count; i++) {
        printf("\"%s\"", paths[i]);
        if (i < path_count - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(m+n))

Still explores all possible path combinations, but with better pruning

✓ Linear Growth

Space Complexity

O(m+n)

Recursion stack plus visited array of size n×n

⚡ Linearithmic Space

34.5K Views

Medium Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Rat in a Maze - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler