01 Matrix

01 Matrix - Problem

Imagine you're standing in a maze of 0s and 1s, and you need to find the shortest path from every cell to the nearest safe zone (0). This is exactly what the 01 Matrix problem asks you to solve!

Given an m × n binary matrix mat containing only 0s and 1s, your task is to calculate the minimum distance from each cell to the nearest 0. Two cells are considered adjacent if they share a common edge (up, down, left, right), and each step has a distance of 1.

Goal: Transform the matrix so that each cell contains the distance to the nearest 0.

Example: If you have a matrix like [[0,0,0],[0,1,0],[1,1,1]], the cell at position (1,1) has a distance of 1 to reach any 0, while the cell at (2,2) has a distance of 2.

Input & Output

example_1.py — Basic Matrix

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

› Output: [[0,0,0],[0,1,0],[0,0,0]]

💡 Note: The center cell (1,1) is already surrounded by zeros at distance 1, so its value becomes 1. All other cells are already zeros.

example_2.py — Complex Matrix

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

› Output: [[0,0,0],[0,1,0],[1,2,1]]

💡 Note: Bottom row: (2,0) and (2,2) are distance 1 from nearest zeros, while (2,1) is distance 2 from the nearest zeros.

example_3.py — Single Element

$ Input: mat = [[0]]

› Output: [[0]]

💡 Note: Edge case with single zero element - distance to itself is 0.

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 10⁴
1 ≤ m * n ≤ 10⁴
mat[i][j] is either 0 or 1
There is at least one 0 in mat

Visualization

Tap to expand

Asked in

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

The optimal solution uses Multi-source BFS starting from all zeros simultaneously. Instead of calculating distance from each cell to nearest zero, we reverse the approach: start BFS from all zeros and propagate distances outward. This guarantees shortest distances in O(mn) time complexity.

Common Approaches

✓ Multi-source BFS (Optimal)

⏱️ Time: O(mn) Space: O(mn)

Instead of calculating distances from each cell to zeros, we reverse the problem: start from all zeros simultaneously and propagate distances outward using BFS. This guarantees shortest distances since BFS explores nodes level by level.

Multi-source BFS (Optimal) — Algorithm Steps

Initialize result matrix and queue
Add all zero positions to queue with distance 0
Mark all non-zero positions as unvisited (infinity)
Perform BFS: for each cell, update neighbors with distance + 1
Continue until queue is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Add all zeros to queue with distance 0

Wave 1

Process distance 0 cells, add neighbors with distance 1

Wave 2

Process distance 1 cells, add neighbors with distance 2

Complete

Continue until all reachable cells are processed

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
/* This is comment */

void updateMatrix(int** mat, int m, int n, int** result) {
    int* queueR = (int*)malloc(m * n * sizeof(int));
    int* queueC = (int*)malloc(m * n * sizeof(int));
    int front = 0, back = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (mat[i][j] == 0) {
                result[i][j] = 0;
                queueR[back] = i;
                queueC[back] = j;
                back++;
            } else {
                result[i][j] = INT_MAX;
            }
        }
    }
    
    int dx[] = {0, 0, 1, -1};
    int dy[] = {1, -1, 0, 0};
    
    while (front < back) {
        int x = queueR[front];
        int y = queueC[front];
        front++;
        
        for (int d = 0; d < 4; d++) {
            int nx = x + dx[d];
            int ny = y + dy[d];
            if (nx >= 0 && nx < m && ny >= 0 && ny < n) {
                if (result[nx][ny] > result[x][y] + 1) {
                    result[nx][ny] = result[x][y] + 1;
                    queueR[back] = nx;
                    queueC[back] = ny;
                    back++;
                }
            }
        }
    }
    
    free(queueR);
    free(queueC);
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int mat[200][200];
    int m = 0, n = 0;
    int temp[200];
    int col = 0;
    char* ptr = line;
    int depth = 0;
    
    while (*ptr) {
        if (*ptr == '[') {
            depth++;
            if (depth == 2) col = 0;
        } else if (*ptr == ']') {
            if (depth == 2) {
                if (m == 0) n = col;
                for (int i = 0; i < col; i++) mat[m][i] = temp[i];
                m++;
            }
            depth--;
        } else if (*ptr >= '0' && *ptr <= '9') {
            int num = 0;
            while (*ptr >= '0' && *ptr <= '9') { num = num * 10 + (*ptr - '0'); ptr++; }
            ptr--;
            temp[col++] = num;
        }
        ptr++;
    }
    
    int** matPtr = (int**)malloc(m * sizeof(int*));
    int** result = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        matPtr[i] = mat[i];
        result[i] = (int*)calloc(n, sizeof(int));
    }
    
    updateMatrix(matPtr, m, n, result);
    
    printf("[");
    for (int i = 0; i < m; i++) {
        printf("[");
        for (int j = 0; j < n; j++) {
            printf("%d", result[i][j]);
            if (j < n - 1) printf(",");
        }
        printf("]");
        if (i < m - 1) printf(",");
    }
    printf("]\n");
    
    for (int i = 0; i < m; i++) free(result[i]);
    free(result);
    free(matPtr);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn)

Each cell is visited exactly once during BFS traversal

✓ Linear Growth

Space Complexity

O(mn)

Queue can contain up to all cells in worst case, plus result matrix

⚡ Linearithmic Space

42.9K Views

High Frequency

~18 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

Multi-source BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler