The Maze II - Practice Coding Problems

The Maze II - Problem

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

The Maze II - Find the Shortest Path for a Rolling Ball

Imagine a ball trapped in a maze that can't stop rolling until it hits a wall! This is a fascinating pathfinding problem where you need to find the shortest distance for the ball to reach its destination.

The Challenge:
Given an m × n maze where 0 represents empty spaces and 1 represents walls, help the ball find the shortest path from start to destination. The twist? The ball keeps rolling in the chosen direction until it hits a wall!

Input: A 2D matrix maze, start position [startRow, startCol], and destination [destRow, destCol]

Output: The shortest distance (number of empty spaces traveled), or -1 if impossible

Key Rules:
• Ball rolls continuously until hitting a wall
• Distance counts empty spaces from start (excluded) to destination (included)
• All maze borders are walls
• Ball can choose direction only when it stops

Input & Output

example_1.py — Basic Maze

$ 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: One possible path is: left -> down -> left -> down -> right -> down -> right. The total distance is 1 + 1 + 3 + 1 + 2 + 2 + 2 = 12.

example_2.py — Impossible 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 the destination. The ball will roll past the destination due to walls blocking it from stopping there.

example_3.py — Same Position

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

› Output: 0

💡 Note: The start and destination are the same, so the distance is 0.

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 start and destination coordinates represent empty spaces
The borders of the maze are all walls

Visualization

Tap to expand

Understanding the Visualization

Understand Rolling

Ball rolls continuously in chosen direction until hitting a wall

Model as Graph

Each stopping position is a node, each roll is a weighted edge

Use Dijkstra's

Since edges have different weights (distances), use shortest path algorithm

Find Optimal Path

Priority queue ensures we find the minimum distance to destination

Key Takeaway

🎯 Key Insight: The maze ball problem is actually a shortest path problem in a weighted graph, where each 'roll' has a different cost (distance). Dijkstra's algorithm guarantees we find the optimal solution by always exploring the shortest known path first!

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28 Apple 22 U Uber 18

The optimal solution uses Dijkstra's algorithm with a priority queue. Since each 'roll' in different directions can cover different distances, this becomes a weighted graph shortest path problem. The key insight is that we need to always explore paths with minimum distance first to guarantee finding the optimal solution. Time complexity: O((m×n) log(m×n)), Space complexity: O(m×n).

Common Approaches

Approach	Time	Space	Notes
✓ Dijkstra's Algorithm (Optimal)	O((m×n) log(m×n))	O(m×n)	Use priority queue to always explore shortest distance paths first
BFS All Paths	O(m×n×max(m,n))	O(m×n)	Use BFS to explore all reachable positions level by level
Brute Force DFS	O(4^(m×n))	O(m×n)	Explore all possible paths using depth-first search with backtracking

Dijkstra's Algorithm (Optimal) — Algorithm Steps

Initialize priority queue with starting position and distance 0
Use min-heap to always process position with smallest distance first
For each position, try all 4 directions and roll until hitting a wall
Calculate total distance and add to priority queue if shorter path found
Mark positions as visited once processed to avoid reprocessing
Return distance when destination is reached, or -1 if unreachable

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize PQ

Start with initial position in priority queue with distance 0

Process Minimum

Always process position with minimum distance first

Add Neighbors

Roll in all directions and add new positions with their distances

Optimal Path

First time we reach destination gives us the optimal distance

Code -

solution.c — C

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

struct PQNode {
    int dist, x, y;
};

struct PriorityQueue {
    struct PQNode* data;
    int size;
    int capacity;
};

struct PriorityQueue* createPQ(int capacity) {
    struct PriorityQueue* pq = (struct PriorityQueue*)malloc(sizeof(struct PriorityQueue));
    pq->data = (struct PQNode*)malloc(capacity * sizeof(struct PQNode));
    pq->size = 0;
    pq->capacity = capacity;
    return pq;
}

void heapifyUp(struct PriorityQueue* pq, int idx) {
    while (idx > 0) {
        int parent = (idx - 1) / 2;
        if (pq->data[idx].dist >= pq->data[parent].dist) break;
        
        struct PQNode temp = pq->data[idx];
        pq->data[idx] = pq->data[parent];
        pq->data[parent] = temp;
        idx = parent;
    }
}

void heapifyDown(struct PriorityQueue* pq, int idx) {
    while (idx < pq->size) {
        int minIdx = idx;
        int left = 2 * idx + 1;
        int right = 2 * idx + 2;
        
        if (left < pq->size && pq->data[left].dist < pq->data[minIdx].dist) {
            minIdx = left;
        }
        if (right < pq->size && pq->data[right].dist < pq->data[minIdx].dist) {
            minIdx = right;
        }
        
        if (minIdx == idx) break;
        
        struct PQNode temp = pq->data[idx];
        pq->data[idx] = pq->data[minIdx];
        pq->data[minIdx] = temp;
        idx = minIdx;
    }
}

void push(struct PriorityQueue* pq, int dist, int x, int y) {
    if (pq->size >= pq->capacity) return;
    
    pq->data[pq->size].dist = dist;
    pq->data[pq->size].x = x;
    pq->data[pq->size].y = y;
    heapifyUp(pq, pq->size);
    pq->size++;
}

struct PQNode pop(struct PriorityQueue* pq) {
    struct PQNode result = pq->data[0];
    pq->size--;
    pq->data[0] = pq->data[pq->size];
    heapifyDown(pq, 0);
    return result;
}

int shortestDistance(int** maze, int mazeSize, int* mazeColSize, int* start, int startSize, int* destination, int destinationSize) {
    if (mazeSize == 0 || mazeColSize[0] == 0) return -1;
    
    int m = mazeSize, n = mazeColSize[0];
    struct PriorityQueue* pq = createPQ(m * n * 4);
    push(pq, 0, start[0], start[1]);
    
    int** visited = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        visited[i] = (int*)calloc(n, sizeof(int));
    }
    
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    
    while (pq->size > 0) {
        struct PQNode curr = pop(pq);
        int dist = curr.dist, x = curr.x, y = curr.y;
        
        // If we reached destination, return distance
        if (x == destination[0] && y == destination[1]) {
            // Clean up
            for (int i = 0; i < m; i++) free(visited[i]);
            free(visited);
            free(pq->data);
            free(pq);
            return dist;
        }
        
        if (visited[x][y]) continue;
        visited[x][y] = 1;
        
        // Try all four directions
        for (int i = 0; i < 4; i++) {
            int nx = x, ny = y, steps = 0;
            int dx = directions[i][0], dy = directions[i][1];
            
            // Roll until hitting a wall
            while (nx + dx >= 0 && nx + dx < m &&
                   ny + dy >= 0 && ny + dy < n &&
                   maze[nx + dx][ny + dy] == 0) {
                nx += dx;
                ny += dy;
                steps++;
            }
            
            if (!visited[nx][ny]) {
                push(pq, dist + steps, nx, ny);
            }
        }
    }
    
    // Clean up
    for (int i = 0; i < m; i++) free(visited[i]);
    free(visited);
    free(pq->data);
    free(pq);
    
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O((m×n) log(m×n))

Each position can be added to priority queue once, and heap operations take O(log(m×n)) time

⚡ Linearithmic

Space Complexity

O(m×n)

Priority queue and visited set can contain up to m×n positions

⚡ Linearithmic Space

67.8K Views

High 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

Dijkstra's Algorithm (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler