The Maze II

The Maze II - Problem

Array Depth-First Search Breadth-First Search Graph Heap (Priority Queue) Matrix Shortest Path Medium

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.

Given the m x n maze, the ball's start position and the destination, where start = [startrow, startcol] and destination = [destinationrow, destinationcol], return the shortest distance for the ball to stop at the destination. If the ball cannot stop at destination, return -1.

The distance is the number of empty spaces traveled by the ball from the start position (excluded) to the destination (included). You may assume that the borders of the maze are all walls.

Input & Output

Example 1 — Basic 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 = [4,4]

› Output: 12

💡 Note: Ball starts at (0,4), rolls left to (0,0), then down to (4,0), then right to (4,4). Total distance: 4 + 4 + 4 = 12 steps

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: -1

💡 Note: There is no way for the ball to stop at destination (3,2) because it's surrounded by walls and unreachable

Example 3 — Direct Path

$ 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 = [4,3], destination = [0,1]

› Output: 6

💡 Note: Ball rolls up from (4,3) to (0,3), then left to (0,1). Distance: 4 + 2 = 6 steps

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 start and destination exist in an empty space

Visualization

Tap to expand

Asked in

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

The key insight is that the ball rolls until it hits a wall, making each stopping position a node in a graph. The optimal approach uses Dijkstra's algorithm with a priority queue to efficiently find the shortest path. Time: O(m×n×log(m×n)), Space: O(m×n)

Common Approaches

✓ BFS Level-by-Level

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

Use a queue to explore positions in breadth-first order. Since we explore by levels, the first time we reach the destination gives us the shortest distance.

DFS with All Paths

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

Recursively explore all four directions from each position, rolling until hitting a wall. Track the minimum distance found to reach the destination.

Dijkstra with Priority Queue

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

Use a priority queue (min-heap) to always process the position with minimum distance first. This ensures optimal path finding and avoids exploring unnecessary longer paths.

BFS Level-by-Level — Algorithm Steps

Start with initial position in queue
For each position, roll in all 4 directions
Add new positions to queue with updated distance
Return distance when destination is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Queue Start

Add starting position to queue

Level by Level

Process all positions at current distance

First Match

First time reaching destination gives shortest path

Code -

solution.c — C

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

#define MAX_SIZE 105
#define MAX_QUEUE 100000

typedef struct {
    int x, y, dist;
} State;

int maze[MAX_SIZE][MAX_SIZE];
int dist[MAX_SIZE][MAX_SIZE];
int rows, cols;
int directions[4][2] = {{0,1},{1,0},{0,-1},{-1,0}};

// Queue
State queue[MAX_QUEUE];
int qFront, qRear;

void queueInit() { qFront = qRear = 0; }
void enqueue(int x, int y, int d) {
    queue[qRear].x = x;
    queue[qRear].y = y;
    queue[qRear].dist = d;
    qRear++;
}
State dequeue() { return queue[qFront++]; }
int queueEmpty() { return qFront == qRear; }

int solution(int sr, int sc, int dr, int dc) {
    // Init dist array
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            dist[i][j] = INT_MAX;

    dist[sr][sc] = 0;
    queueInit();
    enqueue(sr, sc, 0);

    while (!queueEmpty()) {
        State cur = dequeue();
        int x = cur.x, y = cur.y, d = cur.dist;

        // If we already found a shorter path, skip
        if (d > dist[x][y]) continue;

        // Try all 4 directions
        for (int i = 0; i < 4; i++) {
            int nx = x, ny = y, steps = 0;

            // Roll until hitting a wall
            while (nx + directions[i][0] >= 0 &&
                   nx + directions[i][0] < rows &&
                   ny + directions[i][1] >= 0 &&
                   ny + directions[i][1] < cols &&
                   maze[nx + directions[i][0]][ny + directions[i][1]] == 0) {
                nx += directions[i][0];
                ny += directions[i][1];
                steps++;
            }

            int nd = d + steps;

            // Only enqueue if we found a shorter distance
            if (nd < dist[nx][ny]) {
                dist[nx][ny] = nd;
                enqueue(nx, ny, nd);
            }
        }
    }

    return dist[dr][dc] == INT_MAX ? -1 : dist[dr][dc];
}

void parseMaze(char* line) {
    rows = 0; cols = 0;
    int i = 0, len = strlen(line);
    while (i < len && line[i] != '[') i++;
    i++;
    while (i < len) {
        if (line[i] == '[') {
            i++;
            int c = 0;
            while (i < len && line[i] != ']') {
                if (line[i] >= '0' && line[i] <= '9') {
                    maze[rows][c++] = line[i] - '0';
                }
                i++;
            }
            if (rows == 0) cols = c;
            rows++;
        }
        i++;
    }
}

void parseArray(char* line, int* arr) {
    int i = 0, len = strlen(line);
    int idx = 0;
    while (i < len) {
        if (line[i] >= '0' && line[i] <= '9') {
            int num = 0;
            while (i < len && line[i] >= '0' && line[i] <= '9') {
                num = num * 10 + (line[i] - '0');
                i++;
            }
            arr[idx++] = num;
        } else {
            i++;
        }
    }
}

int main() {
    char mazeLine[10000];
    char startLine[100];
    char destLine[100];

    fgets(mazeLine, sizeof(mazeLine), stdin);
    mazeLine[strcspn(mazeLine, "\n")] = '\0';

    fgets(startLine, sizeof(startLine), stdin);
    startLine[strcspn(startLine, "\n")] = '\0';

    fgets(destLine, sizeof(destLine), stdin);
    destLine[strcspn(destLine, "\n")] = '\0';

    parseMaze(mazeLine);

    int start[2], dest[2];
    parseArray(startLine, start);
    parseArray(destLine, dest);

    int result = solution(start[0], start[1], dest[0], dest[1]);
    printf("%d\n", result);

    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n×max(m,n))

Each cell can be visited once, and rolling can take up to max(m,n) steps

✓ Linear Growth

Space Complexity

O(m×n)

Queue can store up to m×n positions, plus visited array

⚡ Linearithmic Space

142.0K Views

Medium Frequency

~25 min Avg. Time

1.9K 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 Level-by-Level — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler