Swim in Rising Water - Practice Coding Problems

Swim in Rising Water - Problem

Array Binary Search Depth-First Search Breadth-First Search Union Find Heap (Priority Queue) Matrix Hard

Imagine you're trapped in a flooding valley represented by an n × n grid where each cell contains an elevation value. As time passes, water continuously rises - at time t, any cell with elevation ≤ t becomes submerged and navigable.

Your Goal: Find the minimum time needed to swim from the top-left corner (0,0) to the bottom-right corner (n-1, n-1).

Swimming Rules:

You can only move to 4-directionally adjacent cells (up, down, left, right)
Both your current cell and destination cell must have elevation ≤ current water level
You can swim infinitely fast once a path is available
You must stay within grid boundaries

Think of it as finding the lowest "bottleneck" elevation that blocks your escape route!

Input & Output

example_1.py — Basic 2×2 Grid

$ Input: grid = [[0,2],[1,3]]

› Output: 3

💡 Note: At time 3, water level is 3. All cells are now accessible (0≤3, 2≤3, 1≤3, 3≤3). We can swim from (0,0) to (1,1) via path: (0,0) → (0,1) → (1,1) or (0,0) → (1,0) → (1,1).

example_2.py — Larger Grid with Bottleneck

$ Input: grid = [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]

› Output: 16

💡 Note: The optimal path requires going through a cell with elevation 16, which becomes the bottleneck. Even though there are cells with higher elevations, the minimum possible maximum elevation on any path is 16.

example_3.py — Single Cell

$ Input: grid = [[5]]

› Output: 5

💡 Note: Edge case: already at destination. The water level must be at least 5 to make the starting cell accessible.

Constraints

n == grid.length
n == grid[i].length
1 ≤ n ≤ 50
0 ≤ grid[i][j] ≤ n² - 1
All values in grid are unique

Visualization

Tap to expand

Understanding the Visualization

Water Rises Over Time

At time t, any elevation ≤ t becomes navigable water

Find Minimum Bottleneck

We need the lowest water level that creates a complete path

Binary Search Optimization

Instead of testing every level, binary search on the answer

Key Takeaway

🎯 Key Insight: This problem is about finding the minimum bottleneck elevation on any path from start to end. Binary search on the water level combined with DFS/BFS provides the optimal O(n² × log(max_val)) solution.

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 25

The optimal approach uses binary search on the water level combined with DFS/BFS for path validation. Key insight: if we can reach destination at level X, we can reach it at any level > X. This monotonic property enables binary search, reducing time complexity from O(max_val × n²) to O(n² × log(max_val)).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Water Levels)	O(max_val * n²)	O(n²)	Test every possible water level from 0 to maximum elevation
Binary Search + DFS (Optimal)	O(n² log(max_val))	O(n²)	Binary search on water level combined with DFS for path checking

Brute Force (Try All Water Levels) — Algorithm Steps

Find the maximum elevation in the grid
For each water level t from 0 to max elevation:
Use DFS/BFS to check if path exists from (0,0) to (n-1,n-1)
Only traverse cells with elevation ≤ t
Return the first t where path exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with water level 0

Check if path exists with only cells ≤ 0 accessible

Increment water level

Try level 1, then 2, then 3... until path found

Path found!

Return the first level where complete path exists

Code -

solution.c — C

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

typedef struct {
    int row, col;
} Point;

typedef struct {
    Point* data;
    int size;
    int capacity;
} Stack;

Stack* createStack(int capacity) {
    Stack* stack = malloc(sizeof(Stack));
    stack->data = malloc(sizeof(Point) * capacity);
    stack->size = 0;
    stack->capacity = capacity;
    return stack;
}

void push(Stack* stack, Point p) {
    stack->data[stack->size++] = p;
}

Point pop(Stack* stack) {
    return stack->data[--stack->size];
}

bool isEmpty(Stack* stack) {
    return stack->size == 0;
}

bool canReach(int** grid, int n, int waterLevel) {
    if (grid[0][0] > waterLevel) return false;
    
    bool** visited = malloc(sizeof(bool*) * n);
    for (int i = 0; i < n; i++) {
        visited[i] = calloc(n, sizeof(bool));
    }
    
    Stack* stack = createStack(n * n);
    Point start = {0, 0};
    push(stack, start);
    visited[0][0] = true;
    
    int dirs[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    
    while (!isEmpty(stack)) {
        Point curr = pop(stack);
        
        if (curr.row == n-1 && curr.col == n-1) {
            // Cleanup
            for (int i = 0; i < n; i++) free(visited[i]);
            free(visited);
            free(stack->data);
            free(stack);
            return true;
        }
        
        for (int i = 0; i < 4; i++) {
            int nr = curr.row + dirs[i][0];
            int nc = curr.col + dirs[i][1];
            
            if (nr >= 0 && nr < n && nc >= 0 && nc < n && 
                !visited[nr][nc] && grid[nr][nc] <= waterLevel) {
                visited[nr][nc] = true;
                Point next = {nr, nc};
                push(stack, next);
            }
        }
    }
    
    // Cleanup
    for (int i = 0; i < n; i++) free(visited[i]);
    free(visited);
    free(stack->data);
    free(stack);
    return false;
}

int swimInWater(int** grid, int n) {
    int maxVal = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] > maxVal) {
                maxVal = grid[i][j];
            }
        }
    }
    
    for (int t = 0; t <= maxVal; t++) {
        if (canReach(grid, n, t)) {
            return t;
        }
    }
    return maxVal;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(max_val * n²)

For each of max_val water levels, we run DFS/BFS which takes O(n²)

⚠ Quadratic Growth

Space Complexity

O(n²)

DFS/BFS uses O(n²) space for visited array and recursion/queue

⚠ Quadratic Space

67.3K Views

Medium-High Frequency

~25 min Avg. Time

2.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 (Try All Water Levels) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler