Shortest Path in Binary Matrix - Practice Coding Problems

Shortest Path in Binary Matrix - Problem

Find the Shortest Clear Path in a Binary Matrix!

You're given an n × n binary matrix where 0 represents an open cell and 1 represents a blocked cell. Your mission is to find the shortest clear path from the top-left corner (0, 0) to the bottom-right corner (n-1, n-1).

Path Rules:
• You can only move through cells containing 0
• You can move in 8 directions (horizontally, vertically, and diagonally)
• The path length is the number of cells visited (including start and end)

If no clear path exists, return -1. Think of it like navigating through a maze where you want to find the quickest route while avoiding obstacles!

Input & Output

example_1.py — Basic Path

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

› Output: 4

💡 Note: The shortest clear path is (0,0) → (0,1) → (0,2) → (1,2) → (2,2) with length 4. We can move diagonally and around obstacles.

example_2.py — No Path

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

› Output: -1

💡 Note: There's no clear path from top-left to bottom-right because the path is completely blocked by obstacles.

example_3.py — Single Cell

$ Input: grid = [[0]]

› Output: 1

💡 Note: The grid has only one cell (0,0) which is both start and destination, so the path length is 1.

Visualization

Tap to expand

Understanding the Visualization

Initialize Queue

Start with source cell (0,0) in the queue with distance 1

Level-by-Level Expansion

Process all cells at current distance before moving to next distance

8-Direction Exploration

From each cell, explore all 8 possible directions (including diagonals)

Early Termination

Return immediately when destination is reached - guaranteed shortest!

Key Takeaway

🎯 Key Insight: BFS guarantees the shortest path because it explores all nodes at distance k before any nodes at distance k+1, making it perfect for unweighted shortest path problems!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we visit every cell in the n×n grid exactly once

⚠ Quadratic Growth

Space Complexity

O(n²)

Queue can contain up to O(n²) cells in worst case, plus visited array

⚠ Quadratic Space

Constraints

n == grid.length
n == grid[i].length
1 ≤ n ≤ 100
grid[i][j] is 0 or 1
You can move in 8 directions (including diagonals)

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses Breadth-First Search (BFS) which naturally finds the shortest path in unweighted graphs. BFS explores nodes level by level, ensuring the first time we reach the destination is via the shortest route. Time complexity: O(n²), Space complexity: O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ BFS - Shortest Path (Optimal)	O(n²)	O(n²)	Use BFS to find shortest path by exploring cells level by level
Brute Force (DFS All Paths)	O(4^(n²))	O(n²)	Explore all possible paths using DFS and track the minimum length

BFS - Shortest Path (Optimal) — Algorithm Steps

Check if start or end is blocked - return -1 if so
Handle edge case: if grid is 1x1 and start is clear, return 1
Initialize BFS queue with starting position (0,0) and distance 1
While queue is not empty, process current level of cells
For each cell, explore all 8 directions
If we reach destination, return the current distance
Add valid unvisited neighbors to queue with distance+1
Mark visited cells to avoid revisiting

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start BFS from (0,0) with distance 1

Level 1

Explore all neighbors at distance 1

Level 2

Explore all neighbors at distance 2

Found!

First time we reach destination = shortest path

Code -

solution.c — C

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

typedef struct {
    int row, col, dist;
} Cell;

typedef struct {
    Cell* data;
    int front, rear, size, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = malloc(sizeof(Queue));
    q->data = malloc(capacity * sizeof(Cell));
    q->front = q->rear = q->size = 0;
    q->capacity = capacity;
    return q;
}

void enqueue(Queue* q, Cell cell) {
    q->data[q->rear] = cell;
    q->rear = (q->rear + 1) % q->capacity;
    q->size++;
}

Cell dequeue(Queue* q) {
    Cell cell = q->data[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return cell;
}

int shortestPathBinaryMatrix(int** grid, int gridSize, int* gridColSize) {
    int n = gridSize;
    
    if (grid[0][0] == 1 || grid[n-1][n-1] == 1) {
        return -1;
    }
    
    if (n == 1) {
        return 1;
    }
    
    int directions[8][2] = {{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};
    
    Queue* queue = createQueue(n * n);
    bool** visited = malloc(n * sizeof(bool*));
    for (int i = 0; i < n; i++) {
        visited[i] = calloc(n, sizeof(bool));
    }
    
    Cell start = {0, 0, 1};
    enqueue(queue, start);
    visited[0][0] = true;
    
    while (queue->size > 0) {
        Cell current = dequeue(queue);
        
        for (int i = 0; i < 8; i++) {
            int newRow = current.row + directions[i][0];
            int newCol = current.col + directions[i][1];
            
            if (newRow >= 0 && newRow < n && newCol >= 0 && newCol < n &&
                grid[newRow][newCol] == 0 && !visited[newRow][newCol]) {
                
                if (newRow == n-1 && newCol == n-1) {
                    // Cleanup
                    for (int j = 0; j < n; j++) free(visited[j]);
                    free(visited);
                    free(queue->data);
                    free(queue);
                    return current.dist + 1;
                }
                
                Cell next = {newRow, newCol, current.dist + 1};
                enqueue(queue, next);
                visited[newRow][newCol] = true;
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) free(visited[i]);
    free(visited);
    free(queue->data);
    free(queue);
    
    return -1;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we visit every cell in the n×n grid exactly once

⚠ Quadratic Growth

Space Complexity

O(n²)

Queue can contain up to O(n²) cells in worst case, plus visited array

⚠ Quadratic Space

Constraints

n == grid.length
n == grid[i].length
1 ≤ n ≤ 100
grid[i][j] is 0 or 1
You can move in 8 directions (including diagonals)

67.2K Views

High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

BFS - Shortest Path (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler