Swim in Rising Water

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

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

✓ Binary Search + DFS (Optimal)

⏱️ Time: O(n² log(max_val)) Space: O(n²)

Instead of trying every water level, binary search on the answer. The key insight is that if we can reach the destination at water level X, we can also reach it at any level > X. This monotonic property allows binary search.

Brute Force (Try All Water Levels)

⏱️ Time: O(max_val * n²) Space: O(n²)

For each possible water level t (from 0 to max grid value), use DFS/BFS to check if a path exists from start to end where all cells have elevation ≤ t. Return the first t where a path is found.

Binary Search + DFS (Optimal) — Algorithm Steps

Set search range: left = max(grid[0][0], grid[n-1][n-1]), right = max(all grid values)
Binary search on water level: mid = (left + right) / 2
For each mid value, use DFS/BFS to check if path exists
If path exists, try smaller water level (right = mid)
If no path, try larger water level (left = mid + 1)
Continue until left == right

Visualization

Tap to expand

Step-by-Step Walkthrough

Set search bounds

left = max(start, end), right = max(all values)

Test middle value

mid = (left + right) / 2, check if path exists

Narrow search space

If path exists, search lower levels; else search higher

Code -

solution.c — C

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

static int n;
static bool** visited;

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

bool dfs(int** grid, int row, int col, int water_level) {
    if (row == n-1 && col == n-1) {
        return true;
    }
    
    visited[row][col] = true;
    
    int dirs[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    for (int i = 0; i < 4; i++) {
        int dr = dirs[i][0], dc = dirs[i][1];
        int nr = row + dr, nc = col + dc;
        if (nr >= 0 && nr < n && nc >= 0 && nc < n && 
            !visited[nr][nc] && grid[nr][nc] <= water_level) {
            if (dfs(grid, nr, nc, water_level)) {
                return true;
            }
        }
    }
    return false;
}

bool canReach(int** grid, int water_level) {
    if (grid[0][0] > water_level) {
        return false;
    }
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            visited[i][j] = false;
        }
    }
    
    return dfs(grid, 0, 0, water_level);
}

int swimInWater(int** grid) {
    int left = grid[0][0] > grid[n-1][n-1] ? grid[0][0] : grid[n-1][n-1];
    int right = 0;
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] > right) {
                right = grid[i][j];
            }
        }
    }
    
    while (left < right) {
        int mid = (left + right) / 2;
        if (canReach(grid, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

int** parseGrid(const char* input, int* gridSize) {
    int len = strlen(input);
    char* clean = malloc(len + 1);
    strcpy(clean, input + 1);
    clean[len-2] = '\0';
    
    *gridSize = 0;
    for (int i = 0; clean[i]; i++) {
        if (clean[i] == '[') (*gridSize)++;
    }
    
    int** grid = malloc(*gridSize * sizeof(int*));
    
    char* token = strtok(clean, "[");
    int rowIndex = 0;
    
    while (token != NULL && rowIndex < *gridSize) {
        char* endBracket = strchr(token, ']');
        if (endBracket) *endBracket = '\0';
        
        int* row = malloc(*gridSize * sizeof(int));
        int size;
        
        char temp[1000];
        sprintf(temp, "[%s]", token);
        parseArray(temp, row, &size);
        
        grid[rowIndex] = row;
        rowIndex++;
        
        token = strtok(NULL, "[");
    }
    
    free(clean);
    return grid;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int gridSize;
    int** grid = parseGrid(input, &gridSize);
    n = gridSize;
    
    visited = malloc(n * sizeof(bool*));
    for (int i = 0; i < n; i++) {
        visited[i] = malloc(n * sizeof(bool));
    }
    
    printf("%d\n", swimInWater(grid));
    
    for (int i = 0; i < n; i++) {
        free(grid[i]);
        free(visited[i]);
    }
    free(grid);
    free(visited);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log(max_val))

Binary search runs log(max_val) times, each iteration runs DFS/BFS in O(n²)

⚠ Quadratic Growth

Space Complexity

O(n²)

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

⚠ 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

Binary Search + DFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler