Swim in Rising Water

t, r, c = heapq.heappop(min_heap)

Pop the cell with the lowest elevation from the min-heap.

This operation selects the next cell to explore with the minimal elevation, which is critical to the best-first search strategy that guarantees minimal maximum elevation path.

min_heap = [[grid[0][0], 0, 0]]

Initialize a min-heap with the starting cell's elevation and coordinates.

The min-heap prioritizes exploration by elevation, enabling the algorithm to always expand the lowest elevation cell next, which is essential for finding the minimal maximum elevation path.

if r == N - 1 and c == N - 1:

Check if the current cell is the destination.

Detecting the destination allows immediate termination, as the first time it is popped corresponds to the minimal maximum elevation path.

if (nei_r < 0 or nei_c < 0 or

Reject invalid neighbor coordinates and skip cells that have already been visited.

This guard clause filters out neighbors that are either outside the grid bounds or already processed. Without it, you risk index errors (out of bounds) and redundant work or cycles (revisiting), which can break correctness or blow up runtime.

nei_r == N or nei_c == N or

Enforce grid boundary constraints on the neighbor row and column.

Negative indices and indices equal to N are outside the valid range [0, N-1]. Explicitly checking these boundary conditions prevents illegal grid access and ensures the search only considers real cells.

new_time = max(t, grid[nei_r][nei_c])

Calculate the new time as the maximum of current time and neighbor's elevation.

This step tracks the maximum elevation along the path, which corresponds to the minimal time needed to reach that cell given rising water levels.

visit = set()

Initialize a set to track visited cells.

The visited set prevents revisiting cells, which avoids infinite loops and redundant processing, ensuring each cell is processed once.

return t

Return the elevation value as the minimum time to swim across.

Returning the elevation at the destination cell represents the minimal time needed, since it is the highest elevation encountered on the optimal path.

(nei_r, nei_c) in visit):

Skip neighbors that are already present in the visited set.

The visited set encodes which cells have already been committed to exploration so they are not re-added and re-expanded. This preserves efficiency and prevents repeated processing of the same coordinate.

visit.add((nei_r, nei_c))

Mark the neighbor cell as visited.

Marking visited immediately upon adding to the heap prevents duplicate entries and ensures each cell is processed once.

heapq.heappush(min_heap, [new_time, nei_r, nei_c])

Push the neighbor cell with its updated time into the min-heap.

Adding the neighbor to the heap with its effective elevation ensures it will be explored in the correct order, maintaining the best-first search invariant.

visit.add((0, 0))

Mark the starting cell as visited.

Marking the start cell visited immediately prevents it from being added multiple times to the heap, ensuring correctness and efficiency.

continue

Continue to the next direction without processing this neighbor.

Immediately continuing avoids executing the downstream logic (marking visited, computing time, pushing to heap) for an invalid or already-seen neighbor. This keeps the algorithm correct and the loop body clean.

while min_heap:

Continue processing while there are cells in the min-heap.

The loop ensures the algorithm explores all reachable cells in order of increasing elevation until the destination is found.

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

Define the four possible movement directions (up, down, left, right).

These directions represent all valid adjacent moves, enabling systematic exploration of neighbors.

for dr, dc in directions:

Iterate over all four possible neighbor directions.

Exploring neighbors systematically ensures all reachable cells are considered for expansion.

nei_r, nei_c = r + dr, c + dc

Calculate the neighbor's row and column indices.

Computing neighbor coordinates is necessary for boundary and visited checks before adding to the heap.

N = len(grid)

Store the size of the grid in variable N.

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