01 Matrix

if 0 <= nr < rows and 0 <= nc < cols and mat[nr][nc] > mat[r][c] + 1:

Check if neighbor is within bounds and if its current distance is greater than the new possible distance.

This compound condition ensures only valid neighbors are processed and that distances are updated only when a shorter path is found, preventing redundant work and infinite loops.

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

Check if the current cell contains zero.

Identifying zero cells is critical because they serve as BFS starting points for distance propagation.

q.append((r, c))

Add zero cells to the BFS queue as starting points.

Enqueuing all zero cells initially enables multi-source BFS, which efficiently computes shortest distances to zeros.

mat[r][c] = float('inf')

Set the distance of one cells to infinity.

Assigning infinity marks these cells as unvisited and ensures that any discovered shorter distance will update them correctly during BFS.

r, c = q.popleft()

Dequeue the next cell to process.

Dequeuing maintains BFS's FIFO order, which is essential for guaranteeing shortest path discovery.

mat[nr][nc] = mat[r][c] + 1

Update the neighbor's distance to the shorter path found.

Assigning the new distance reflects the shortest path discovered so far and enables correct BFS propagation.

q = deque()

Initialize a queue to hold cells for BFS traversal.

The queue is essential for BFS, enabling layer-by-layer exploration starting from all zero cells.

while q:

Continue BFS while there are cells in the queue.

The loop processes cells layer by layer, ensuring distances are propagated in order of increasing distance from zero cells.

q.append((nr, nc))

Enqueue the neighbor for further BFS exploration.

Adding the neighbor to the queue ensures its neighbors will be explored in subsequent BFS layers, continuing the distance propagation.

else:

Handle cells that contain one.

Cells with value one are not sources and need their distances initialized to infinity to indicate they are unvisited.

directions = [(1,0), (-1,0), (0,1), (0,-1)]

Define the four possible directions for neighbor exploration (up, down, left, right).

These direction vectors enable systematic neighbor traversal in the grid, which is fundamental to BFS expansion.

for dr, dc in directions:

Iterate over all four neighbor directions.

Exploring neighbors is necessary to propagate distance updates to adjacent cells.

return mat

Return the matrix with updated distances.

After BFS completes, the matrix contains the shortest distances to the nearest zero for every cell, fulfilling the problem requirements.

nr, nc = r + dr, c + dc

Calculate the neighbor's row and column indices.

Computing neighbor coordinates allows boundary checks and distance updates for valid neighbors.

for r in range(rows):

Iterate over each row index.

This nested loop structure systematically visits every cell in the matrix to initialize BFS sources and distances.

for c in range(cols):

Iterate over each column index within the current row.

Completes the traversal of the entire matrix grid cell by cell.

rows, cols = len(mat), len(mat[0])

Calculate the number of rows and columns in the matrix.

Caching the dimensions avoids repeated calls to len() and simplifies boundary checks throughout the algorithm.