Walls and Gates

if rooms[r][c] == 0:

Check if the current cell is a gate (value 0).

Identifying gates is critical because BFS starts from these cells to propagate distances.

q.append([r, c])

Add the gate's coordinates to the BFS queue.

Enqueuing all gates initially sets up the multi-source BFS, enabling simultaneous distance propagation.

rooms[r][c] = dist

Update the current cell's distance in the grid.

Assigning the BFS layer number as the distance ensures the shortest distance from the nearest gate is recorded.

if (r < 0 or r == ROWS or c < 0 or c == COLS or

Check if the neighbor is out of grid bounds.

Boundary checks prevent invalid memory access and ensure BFS only processes valid cells.

(r, c) in visit or rooms[r][c] == -1):

Check if the neighbor is already visited or is a wall (-1).

Avoiding walls and revisited cells prevents BFS from traversing invalid or redundant paths, maintaining correctness and efficiency.

visit.add((r, c))

Mark the neighbor as visited.

Marking neighbors as visited upon enqueueing prevents multiple insertions and infinite loops.

visit = set()

Initialize a set to track visited cells.

The visited set prevents revisiting cells during BFS, which avoids infinite loops and redundant processing.

visit.add((r, c))

Mark the gate as visited.

Marking gates as visited prevents them from being reprocessed, ensuring BFS correctness and efficiency.

r, c = q.popleft()

Dequeue the next cell to process.

Dequeuing maintains BFS order, processing cells in increasing distance order from gates.

return

Return early if the neighbor is invalid.

Early exit avoids unnecessary processing and maintains BFS correctness by skipping invalid neighbors.

q.append([r, c])

Add the neighbor's coordinates to the BFS queue.

Enqueuing valid neighbors schedules them for distance assignment in subsequent BFS layers.

q = collections.deque()

Create a queue to perform BFS.

A queue is essential for BFS to process nodes in order of increasing distance from the sources.

while q:

Continue BFS while there are cells to process.

The loop ensures all reachable rooms are processed layer by layer until no new rooms remain.

for i in range(len(q)):

Process all cells in the current BFS layer.

Iterating over the current queue length ensures that all nodes at the current distance are processed before incrementing distance.

dist += 1

Increment the distance counter after processing the current BFS layer.

Increasing the distance reflects moving outward one step further from the gates in BFS traversal.

def add_room(r, c):

Define a helper function to add valid neighboring rooms to the BFS queue.

Encapsulating neighbor validation and queue insertion improves code clarity and correctness by centralizing boundary and visitation checks.

dist = 0

Initialize the distance counter for BFS layers.

The distance variable tracks the current BFS level, corresponding to the distance from gates to rooms.

for r in range(ROWS):

Iterate over each row in the grid.

This loop scans the entire grid to locate all gates, which are BFS starting points.

for c in range(COLS):

Iterate over each column in the current row.

Nested iteration ensures every cell in the grid is examined for gates.

ROWS, COLS = len(rooms), len(rooms[0])

Store the number of rows and columns in the grid.

Caching grid dimensions simplifies boundary checks and improves code readability by avoiding repeated calls to len().