Shortest Path in Binary Matrix

Shortest Path in Binary Matrix - Problem

Given an n x n binary matrix grid, return the length of the shortest clear path in the matrix. If there is no clear path, return -1.

A clear path in a binary matrix is a path from the top-left cell (i.e., (0, 0)) to the bottom-right cell (i.e., (n - 1, n - 1)) such that:

All the visited cells of the path are 0.
All the adjacent cells of the path are 8-directionally connected (i.e., they are different and they share an edge or a corner).

The length of a clear path is the number of visited cells of this path.

Input & Output

Example 1 — Basic Path Found

$ 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). Path length is 4.

Example 2 — No Path Possible

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

› Output: -1

💡 Note: No clear path exists from top-left to bottom-right due to blocking 1s.

Example 3 — Single Cell

$ Input: grid = [[0]]

› Output: 1

💡 Note: Start and end are the same cell (0,0). Path length is 1.

Constraints

n == grid.length
n == grid[i].length
1 ≤ n ≤ 100
grid[i][j] is 0 or 1

Visualization

Tap to expand

Asked in

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

The key insight is that BFS naturally finds the shortest path in unweighted grids by exploring level-by-level. The optimal approach uses Breadth-First Search starting from (0,0) and exploring all 8 directions until reaching (n-1,n-1). Time: O(n²), Space: O(n²)

Common Approaches

✓ Breadth-First Search (Optimal)

⏱️ Time: O(n²) Space: O(n²)

Use BFS to explore the matrix level by level. BFS guarantees that the first time we reach the destination, we've found the shortest path.

DFS with Backtracking

⏱️ Time: O(4ⁿ) Space: O(n²)

Recursively explore all possible paths from (0,0) to (n-1,n-1) using DFS. Track the minimum path length found across all valid paths.

Breadth-First Search (Optimal) — Algorithm Steps

Start BFS from (0,0) if it's 0
Explore all 8-directional neighbors level by level
Mark visited cells to avoid cycles
Return path length when destination is reached

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 1

Start at (0,0), explore immediate neighbors

Level 2

Explore neighbors of level 1 cells

Found

First path to destination is shortest

Code -

solution.c — C

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

typedef struct {
    int row, col, pathLength;
} QueueNode;

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

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

void enqueue(Queue* q, int row, int col, int pathLength) {
    q->data[q->rear].row = row;
    q->data[q->rear].col = col;
    q->data[q->rear].pathLength = pathLength;
    q->rear = (q->rear + 1) % q->capacity;
}

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

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

int solution(int** grid, int n) {
    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);
    int** visited = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        visited[i] = (int*)calloc(n, sizeof(int));
    }
    
    enqueue(queue, 0, 0, 1);
    visited[0][0] = 1;
    
    while (!isEmpty(queue)) {
        QueueNode current = dequeue(queue);
        int row = current.row, col = current.col, pathLength = current.pathLength;
        
        for (int i = 0; i < 8; i++) {
            int newRow = row + directions[i][0];
            int newCol = col + directions[i][1];
            
            if (newRow == n-1 && newCol == n-1) {
                for (int j = 0; j < n; j++) free(visited[j]);
                free(visited);
                free(queue->data);
                free(queue);
                return pathLength + 1;
            }
            
            if (newRow >= 0 && newRow < n && newCol >= 0 && newCol < n &&
                grid[newRow][newCol] == 0 && !visited[newRow][newCol]) {
                visited[newRow][newCol] = 1;
                enqueue(queue, newRow, newCol, pathLength + 1);
            }
        }
    }
    
    for (int i = 0; i < n; i++) free(visited[i]);
    free(visited);
    free(queue->data);
    free(queue);
    return -1;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] == '[' && i > 0) n++;
    }
    
    int** grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
    }
    
    char* ptr = line + 1;
    for (int i = 0; i < n; i++) {
        ptr = strchr(ptr, '[') + 1;
        for (int j = 0; j < n; j++) {
            grid[i][j] = strtol(ptr, &ptr, 10);
            if (*ptr == ',') ptr++;
        }
        ptr = strchr(ptr, ']') + 1;
    }
    
    printf("%d\n", solution(grid, n));
    
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each cell is visited at most once, total n² cells

✓ Linear Growth

Space Complexity

O(n²)

Queue can hold up to n² cells and visited array of size n²

⚠ Quadratic Space

87.0K Views

High 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

Breadth-First Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler