The Maze

The Maze - Problem

There is a ball in a maze with empty spaces (represented as 0) and walls (represented as 1). The ball can go through the empty spaces by rolling up, down, left or right, but it won't stop rolling until hitting a wall.

When the ball stops, it could choose the next direction to roll. Given the m x n maze, the ball's start position and the destination, where start = [startrow, startcol] and destination = [destinationrow, destinationcol], return true if the ball can stop at the destination, otherwise return false.

You may assume that the borders of the maze are all walls.

Input & Output

Example 1 — Path Exists

$ Input: maze = [[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]], start = [0,4], destination = [4,4]

› Output: true

💡 Note: Ball starts at (0,4), rolls down to (4,4), then rolls right to reach destination (4,4)

Example 2 — No Path

$ Input: maze = [[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]], start = [0,4], destination = [3,2]

› Output: false

💡 Note: Ball cannot stop at (3,2) because it's blocked by walls and there's no path that allows stopping there

Example 3 — Start Equals Destination

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

› Output: true

💡 Note: Ball is already at destination, so return true immediately

Constraints

m == maze.length
n == maze[i].length
1 ≤ m, n ≤ 100
maze[i][j] is 0 or 1
start.length == 2
destination.length == 2
0 ≤ start_row, destination_row < m
0 ≤ start_col, destination_col < n
Both the ball and the destination exist in an empty space, and they will not be in the same position initially
The maze contains at least 2 empty spaces

Visualization

Tap to expand

Asked in

G Google 42 f Facebook 38 a Amazon 35 M Microsoft 28

The key insight is that the ball only stops when it hits a wall, not at every cell. Best approach is DFS with visited tracking to avoid revisiting positions. Time: O(m×n), Space: O(m×n)

Common Approaches

✓ BFS with Queue

⏱️ Time: O(m×n) Space: O(m×n)

Instead of DFS, use BFS with a queue to explore all positions the ball can reach. This approach systematically visits all reachable stopping points and can be more intuitive for understanding the ball's movement pattern.

Brute Force DFS

⏱️ Time: O(4^(m×n)) Space: O(m×n)

Use depth-first search to explore all possible paths. From each position where the ball stops, try rolling in all four directions until hitting a wall. Continue recursively until reaching destination or exhausting all possibilities.

DFS with Visited Set

⏱️ Time: O(m×n) Space: O(m×n)

Optimize the brute force approach by maintaining a visited set. This prevents exploring the same stopping position multiple times, significantly reducing redundant work while still guaranteeing to find a solution if it exists.

BFS with Queue — Algorithm Steps

Initialize queue with start position
Mark start as visited
For each position in queue, try rolling in all 4 directions
Add new stopping positions to queue if not visited

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Start with initial position in queue

Process Level

Explore all 4 directions from current position

Add New Positions

Add newly reached stopping points to queue

Code -

solution.c — C

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

typedef struct {
    int x, y;
} Point;

typedef struct {
    Point data[10000];
    int front, rear;
} Queue;

void initQueue(Queue* q) {
    q->front = q->rear = 0;
}

void enqueue(Queue* q, Point p) {
    q->data[q->rear++] = p;
}

Point dequeue(Queue* q) {
    return q->data[q->front++];
}

bool isEmpty(Queue* q) {
    return q->front == q->rear;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

void parseMaze(const char* str, int maze[100][100], int* rows, int* cols) {
    *rows = 0;
    *cols = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        if (*p == '[') {
            p++;
            int col = 0;
            while (*p && *p != ']') {
                while (*p == ' ' || *p == ',') p++;
                if (*p == ']' || *p == '\0') break;
                maze[*rows][col++] = (int)strtol(p, (char**)&p, 10);
            }
            if (*rows == 0) *cols = col;
            (*rows)++;
            if (*p == ']') p++;
        } else {
            p++;
        }
    }
}

bool solution(int maze[100][100], int rows, int cols, int* start, int* destination) {
    if (start[0] == destination[0] && start[1] == destination[1]) {
        return true;
    }
    
    Queue queue;
    initQueue(&queue);
    bool visited[100][100];
    memset(visited, false, sizeof(visited));
    
    Point startPoint = {start[0], start[1]};
    enqueue(&queue, startPoint);
    visited[start[0]][start[1]] = true;
    
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    
    while (!isEmpty(&queue)) {
        Point curr = dequeue(&queue);
        int x = curr.x, y = curr.y;
        
        for (int i = 0; i < 4; i++) {
            int dx = directions[i][0], dy = directions[i][1];
            int nx = x, ny = y;
            
            while (0 <= nx + dx && nx + dx < rows && 
                   0 <= ny + dy && ny + dy < cols && 
                   maze[nx + dx][ny + dy] == 0) {
                nx += dx;
                ny += dy;
            }
            
            if (nx == destination[0] && ny == destination[1]) {
                return true;
            }
            
            if (!visited[nx][ny]) {
                visited[nx][ny] = true;
                Point next = {nx, ny};
                enqueue(&queue, next);
            }
        }
    }
    
    return false;
}

int main() {
    char line1[10000], line2[1000], line3[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    fgets(line3, sizeof(line3), stdin);
    
    int maze[100][100];
    int rows, cols;
    parseMaze(line1, maze, &rows, &cols);
    
    int start[10], destination[10];
    int startSize, destSize;
    parseArray(line2, start, &startSize);
    parseArray(line3, destination, &destSize);
    
    bool result = solution(maze, rows, cols, start, destination);
    printf("%s\n", result ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Each cell visited at most once, queue operations are O(1)

✓ Linear Growth

Space Complexity

O(m×n)

Queue and visited set can store up to m×n positions

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

BFS with Queue — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler