Walls and Gates

Walls and Gates - Problem

You are given an m x n grid rooms initialized with these three possible values:

-1 - A wall or an obstacle
0 - A gate
INF - Infinity means an empty room. We use the value 2³¹ - 1 = 2147483647 to represent INF as you may assume that the distance to a gate is less than 2147483647

Fill each empty room with the distance to its nearest gate. If it is impossible to reach a gate, it should be filled with INF.

Input & Output

Example 1 — Basic Grid with Gates and Walls

$ Input: rooms = [[2147483647,-1,0,2147483647],[2147483647,2147483647,2147483647,-1],[2147483647,-1,2147483647,-1],[0,-1,2147483647,2147483647]]

› Output: [[3,-1,0,1],[2,2,1,-1],[1,-1,2,-1],[0,-1,3,4]]

💡 Note: Gates at (0,2) and (3,0) spread their distances. Room at (0,0) is 3 steps from nearest gate, room at (0,3) is 1 step from gate at (0,2).

Example 2 — Single Room

$ Input: rooms = [[-1]]

› Output: [[-1]]

💡 Note: Only a wall, no changes needed since there are no gates or empty rooms.

Example 3 — Unreachable Room

$ Input: rooms = [[2147483647,-1],[0,2147483647]]

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

💡 Note: Gate at (1,0) cannot reach room at (0,0) due to wall at (0,1). Room at (1,1) cannot reach gate either.

Constraints

m == rooms.length
n == rooms[i].length
1 ≤ m, n ≤ 250
rooms[i][j] is -1, 0, or 2³¹ - 1

Visualization

Tap to expand

Asked in

G Google 42 f Facebook 38 a Amazon 35 M Microsoft 28

The key insight is to start BFS from all gates simultaneously rather than searching from each empty room. This multi-source BFS approach ensures each cell is visited exactly once, giving us optimal O(mn) time complexity. Best approach is Multi-Source BFS. Time: O(mn), Space: O(mn)

Common Approaches

✓ Brute Force - DFS from Each Room

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

For every empty room (INF), perform DFS to find the minimum distance to any gate. This explores all possible paths from each room to every reachable gate.

Multi-Source BFS (Optimal)

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

Start BFS from all gates at once. In each level, expand to neighboring empty rooms and mark them with the current distance. This ensures each room gets the shortest distance to any gate.

Brute Force - DFS from Each Room — Algorithm Steps

Iterate through each cell in the grid
If cell is empty (INF), perform DFS to find nearest gate
Update cell with minimum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Room

Pick an empty room (INF) to process

DFS Search

Explore all paths from this room to find gates

Update Distance

Set room to minimum distance found

Code -

solution.c — C

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

#define INF 2147483647
#define MAX_SIZE 1000
#define MAX_VISITED 10000

typedef struct {
    int row;
    int col;
} Pair;

typedef struct {
    Pair data[MAX_VISITED];
    int size;
} VisitedSet;

void initVisitedSet(VisitedSet* set) {
    set->size = 0;
}

int containsPair(VisitedSet* set, int row, int col) {
    for (int i = 0; i < set->size; i++) {
        if (set->data[i].row == row && set->data[i].col == col) {
            return 1;
        }
    }
    return 0;
}

void insertPair(VisitedSet* set, int row, int col) {
    if (!containsPair(set, row, col)) {
        set->data[set->size].row = row;
        set->data[set->size].col = col;
        set->size++;
    }
}

void erasePair(VisitedSet* set, int row, int col) {
    for (int i = 0; i < set->size; i++) {
        if (set->data[i].row == row && set->data[i].col == col) {
            for (int j = i; j < set->size - 1; j++) {
                set->data[j] = set->data[j + 1];
            }
            set->size--;
            break;
        }
    }
}

int min4(int a, int b, int c, int d) {
    int min1 = a < b ? a : b;
    int min2 = c < d ? c : d;
    return min1 < min2 ? min1 : min2;
}

int dfs(int** rooms, int m, int n, int i, int j, VisitedSet* visited) {
    if (i < 0 || i >= m || j < 0 || j >= n || rooms[i][j] == -1 || containsPair(visited, i, j)) {
        return INF;
    }
    if (rooms[i][j] == 0) return 0;
    
    insertPair(visited, i, j);
    int minDist = min4(
        dfs(rooms, m, n, i+1, j, visited),
        dfs(rooms, m, n, i-1, j, visited),
        dfs(rooms, m, n, i, j+1, visited),
        dfs(rooms, m, n, i, j-1, visited)
    );
    erasePair(visited, i, j);
    
    return minDist == INF ? INF : minDist + 1;
}

void parseMatrix(const char* str, int*** rooms, int* m, int* n) {
    // Remove outer brackets and count rows
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    // First pass: count rows and columns
    *m = 0;
    *n = 0;
    const char* temp = p;
    int inRow = 0;
    
    while (*temp) {
        if (*temp == '[') {
            if (inRow == 0) {
                (*m)++;
                inRow = 1;
                temp++;
                // Count columns in first row only
                if (*m == 1) {
                    const char* colTemp = temp;
                    while (*colTemp && *colTemp != ']') {
                        while (*colTemp == ' ') colTemp++;
                        if (*colTemp == ']') break;
                        (*n)++;
                        // Skip this number
                        if (*colTemp == '-') colTemp++;
                        while (*colTemp >= '0' && *colTemp <= '9') colTemp++;
                        while (*colTemp == ' ') colTemp++;
                        if (*colTemp == ',') colTemp++;
                    }
                }
            }
        } else if (*temp == ']') {
            if (inRow == 1) {
                inRow = 0;
            }
        }
        temp++;
    }
    
    // Allocate memory
    *rooms = (int**)malloc(*m * sizeof(int*));
    for (int i = 0; i < *m; i++) {
        (*rooms)[i] = (int*)malloc(*n * sizeof(int));
    }
    
    // Second pass: parse values
    p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    int row = 0;
    while (*p && row < *m) {
        // Find start of row
        while (*p && *p != '[') p++;
        if (*p == '[') p++;
        
        // Parse numbers in this row
        int col = 0;
        while (*p && *p != ']' && col < *n) {
            while (*p == ' ' || *p == ',') p++;
            if (*p == ']') break;
            
            // Parse number
            (*rooms)[row][col] = (int)strtol(p, (char**)&p, 10);
            col++;
        }
        
        // Skip to end of row
        while (*p && *p != ']') p++;
        if (*p == ']') p++;
        
        row++;
    }
}

void solution(int** rooms, int m, int n) {
    if (!rooms || m == 0 || n == 0) return;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (rooms[i][j] == INF) {
                VisitedSet visited;
                initVisitedSet(&visited);
                rooms[i][j] = dfs(rooms, m, n, i, j, &visited);
            }
        }
    }
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    int** rooms;
    int m, n;
    parseMatrix(input, &rooms, &m, &n);
    
    solution(rooms, m, n);
    
    // Print result
    printf("[");
    for (int i = 0; i < m; i++) {
        printf("[");
        for (int j = 0; j < n; j++) {
            printf("%d", rooms[i][j]);
            if (j < n - 1) printf(",");
        }
        printf("]");
        if (i < m - 1) printf(",");
    }
    printf("]\n");
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(rooms[i]);
    }
    free(rooms);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of m×n cells, DFS can visit all m×n cells in worst case

⚠ Quadratic Growth

Space Complexity

O(mn)

DFS recursion stack can go up to m×n depth in worst case

⚡ Linearithmic Space

89.2K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force - DFS from Each Room — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler