Trapping Rain Water II

Trapping Rain Water II - Problem

Given an m x n integer matrix heightMap representing the height of each unit cell in a 2D elevation map, return the volume of water it can trap after raining.

Water can flow from one cell to another if the height difference allows it. Water will flow out if it can reach the boundary of the matrix.

Example: If we have a heightMap like [[3,3,3],[3,2,3],[3,3,3]], the center cell with height 2 can trap 1 unit of water (making effective height 3).

Input & Output

Example 1 — Simple Basin

$ Input: heightMap = [[3,3,3,3,4],[3,2,2,3,4],[3,2,1,3,4],[4,4,4,4,4]]

› Output: 5

💡 Note: The basin in the middle can trap water. Cell (2,2) with height 1 can hold water up to level 3 (trapped: 2). Cells (1,1), (1,2), (2,1) with height 2 can hold water up to level 3 (trapped: 1 each). Total: 2 + 1 + 1 + 1 = 5.

Example 2 — No Water Trapped

$ Input: heightMap = [[1,4,3,1,3,2],[3,2,1,3,2,4],[2,3,3,2,3,1]]

› Output: 4

💡 Note: Some interior cells can trap water where they are surrounded by higher cells that create barriers to the boundary.

Example 3 — Single Cell

$ Input: heightMap = [[5]]

› Output: 0

💡 Note: Single cell cannot trap any water as it's also a boundary cell.

Constraints

m == heightMap.length
n == heightMap[i].length
1 ≤ m, n ≤ 200
0 ≤ heightMap[i][j] ≤ 2 × 10⁴

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 f Facebook 15 M Microsoft 10

The key insight is that water level at each cell is determined by the minimum barrier height needed to reach any boundary. The optimal approach uses a priority queue (min-heap) starting from boundaries, processing cells in order of increasing water level. Time: O(m×n×log(m×n)), Space: O(m×n).

Common Approaches

✓ Brute Force - Check Each Cell

⏱️ Time: O(m×n×4^(m×n)) Space: O(m×n)

For each interior cell, use DFS/BFS to find all possible paths to the boundary and determine the minimum maximum height along any path. The water level equals this minimum barrier height.

Priority Queue (Dijkstra-like)

⏱️ Time: O(m×n×log(m×n)) Space: O(m×n)

Start from all boundary cells with water level equal to their height. Use a min-heap to process cells in order of increasing water level. For each cell, update neighbors' water levels and add unvisited neighbors to the heap.

Brute Force - Check Each Cell — Algorithm Steps

For each cell (i,j)
Find all paths from (i,j) to boundary using DFS
For each path, find the maximum height along the path
Take minimum of all path maximums
Water trapped = max(0, min_barrier_height - heightMap[i][j])

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Interior Cell

Choose a cell not on the boundary

Explore All Paths

Use DFS to find every possible path to boundary

Find Minimum Barrier

Take the minimum of maximum heights along all paths

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#define MAX_SIZE 200

int heightMap[MAX_SIZE][MAX_SIZE];
int visited[MAX_SIZE][MAX_SIZE];
int m, n;
int minBarrier;

void dfs(int r, int c, int maxHeightSoFar) {
    if (r == 0 || r == m-1 || c == 0 || c == n-1) {
        if (maxHeightSoFar < minBarrier) {
            minBarrier = maxHeightSoFar;
        }
        return;
    }
    
    if (visited[r][c] || maxHeightSoFar >= minBarrier) {
        return;
    }
    
    visited[r][c] = 1;
    int directions[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    for (int i = 0; i < 4; i++) {
        int nr = r + directions[i][0];
        int nc = c + directions[i][1];
        if (nr >= 0 && nr < m && nc >= 0 && nc < n) {
            int newMaxHeight = (heightMap[nr][nc] > maxHeightSoFar) ? heightMap[nr][nc] : maxHeightSoFar;
            dfs(nr, nc, newMaxHeight);
        }
    }
    visited[r][c] = 0;
}

int findMinEscapeHeight(int startR, int startC) {
    memset(visited, 0, sizeof(visited));
    minBarrier = INT_MAX;
    dfs(startR, startC, heightMap[startR][startC]);
    return minBarrier;
}

int solution() {
    if (m <= 2 || n <= 2) return 0;
    
    int totalWater = 0;
    for (int i = 1; i < m-1; i++) {
        for (int j = 1; j < n-1; j++) {
            int minEscape = findMinEscapeHeight(i, j);
            if (minEscape > heightMap[i][j]) {
                totalWater += minEscape - heightMap[i][j];
            }
        }
    }
    
    return totalWater;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse 2D array - simple parsing for small inputs
    char *ptr = line + 1; // Skip first [
    m = 0;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            n = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9' || *ptr == '-') {
                    heightMap[m][n] = atoi(ptr);
                    n++;
                    while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
                    if (*ptr == ',') ptr++;
                } else {
                    ptr++;
                }
            }
            m++;
            if (*ptr == ']') ptr++;
            if (*ptr == ',') ptr++;
        } else {
            ptr++;
        }
    }
    
    printf("%d\n", solution());
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n×4^(m×n))

For each of m×n cells, we explore all possible paths to boundary, which can be exponential

✓ Linear Growth

Space Complexity

O(m×n)

Recursion stack depth for DFS traversal

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~35 min Avg. Time

890 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 - Check Each Cell — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler