Walls and Gates - Practice Coding Problems

Walls and Gates - Problem

Imagine you're designing a smart navigation system for a building! You have an m × n grid representing rooms in a building, where each cell can be:

-1: A wall or obstacle (impassable)
0: A gate (exit point)
INF: An empty room (represented as 2147483647)

Your task is to fill each empty room with the shortest distance to its nearest gate. If a room cannot reach any gate, it should remain INF.

Example: If a room is 3 steps away from the nearest gate, replace INF with 3.

Think of this as calculating evacuation distances - how quickly can someone get from any room to the nearest exit?

Input & Output

example_1.py — Basic Building Layout

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

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

💡 Note: Starting from gates at (0,2) and (3,0), we calculate shortest distances: rooms adjacent to gates get distance 1, rooms 2 steps away get distance 2, etc. Walls (-1) remain unchanged.

example_2.py — Single Gate

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

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

💡 Note: With only one gate at (0,2), distances radiate outward: adjacent rooms get 1, rooms 2 steps away get 2, etc. The bottom-left room requires 3 steps to reach the gate.

example_3.py — Unreachable Room

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

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

💡 Note: The rightmost room is completely blocked by the wall and cannot reach the gate, so it remains INF (2147483647).

Visualization

Tap to expand

Understanding the Visualization

Identify All Exits

Mark all emergency exits (gates) as starting points with distance 0

Simultaneous Expansion

From all exits, simultaneously mark adjacent rooms with distance 1

Ripple Effect

Continue expanding outward like ripples, marking rooms with distances 2, 3, 4...

Optimal Distances

Each room now shows the shortest evacuation path to any exit

Key Takeaway

🎯 Key Insight: Multi-source BFS from all gates simultaneously guarantees each room gets the shortest possible distance to any exit in optimal O(mn) time.

Time & Space Complexity

Time Complexity

⏱️

O(mn)

Each cell is visited at most once during the BFS traversal

✓ Linear Growth

Space Complexity

O(mn)

Queue can contain up to mn cells in worst case (all cells are gates)

⚡ Linearithmic Space

Constraints

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

Asked in

G Google 28 a Amazon 35 f Meta 22 ⊞ Microsoft 18 Apple 15

The optimal approach uses Multi-Source BFS starting from all gates simultaneously. Instead of searching from each room to find gates, we reverse the problem: start from all gates and expand outward, guaranteeing each room gets the shortest distance in O(mn) time.

Common Approaches

Approach	Time	Space	Notes
✓ Multi-Source BFS (Optimal)	O(mn)	O(mn)	Start BFS from all gates simultaneously to find shortest paths
Brute Force (DFS from Each Room)	O(m²n²)	O(mn)	For each empty room, run DFS/BFS to find the nearest gate

Multi-Source BFS (Optimal) — Algorithm Steps

Find all gates (cells with value 0) and add them to the BFS queue
Start BFS from all gates simultaneously with distance 0
For each cell popped from queue, explore its 4 neighbors
If neighbor is an empty room (INF), update it with current distance + 1
Add newly updated rooms to queue for further exploration
Continue until queue is empty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Add all gates (0) to BFS queue as starting points

Expand Level by Level

Process all distance-1 rooms, then distance-2, etc.

Update Neighbors

Only update empty rooms (INF) with current distance + 1

Complete Coverage

Continue until all reachable rooms are updated

Code -

solution.c — C

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

#define INF INT_MAX

typedef struct {
    int row, col;
} Point;

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

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

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

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

void wallsAndGates(int** rooms, int roomsSize, int* roomsColSize) {
    if (roomsSize == 0 || roomsColSize[0] == 0) return;
    
    int m = roomsSize, n = roomsColSize[0];
    Queue* q = createQueue(m * n);
    
    // Add all gates to queue
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (rooms[i][j] == 0) {
                enqueue(q, i, j);
            }
        }
    }
    
    int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    
    while (q->size > 0) {
        Point curr = dequeue(q);
        
        for (int i = 0; i < 4; i++) {
            int newRow = curr.row + directions[i][0];
            int newCol = curr.col + directions[i][1];
            
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n &&
                rooms[newRow][newCol] == INF) {
                rooms[newRow][newCol] = rooms[curr.row][curr.col] + 1;
                enqueue(q, newRow, newCol);
            }
        }
    }
    
    free(q->data);
    free(q);
}

Time & Space Complexity

Time Complexity

⏱️

O(mn)

Each cell is visited at most once during the BFS traversal

✓ Linear Growth

Space Complexity

O(mn)

Queue can contain up to mn cells in worst case (all cells are gates)

⚡ Linearithmic Space

Constraints

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

68.2K Views

High 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Multi-Source BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler