Trapping Rain Water

Trapping Rain Water - Problem

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining.

The elevation map is represented by an array height where height[i] is the height of the bar at position i.

Example: For heights [0,1,0,2,1,0,1,3,2,1,2,1], the trapped water would be 6 units.

Input & Output

Example 1 — Classic Case

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

› Output: 6

💡 Note: Water gets trapped in valleys: at indices 2 (1 unit), 5 (2 units), 6 (1 unit), 9 (1 unit), 10 (1 unit) for total of 6 units

Example 2 — Simple Valley

$ Input: height = [3,0,2,0,4]

› Output: 7

💡 Note: Water gets trapped in valleys: at position 1 (3 units), position 2 (1 unit), and position 3 (3 units), for a total of 7 units

Example 3 — No Water

$ Input: height = [3,2,1]

› Output: 0

💡 Note: Decreasing heights cannot trap any water - water would flow off the right side

Constraints

n == height.length
1 ≤ n ≤ 2 × 10⁴
0 ≤ height[i] ≤ 3 × 10⁴

Visualization

Tap to expand

Asked in

a Amazon 85 G Google 72 f Facebook 68 M Microsoft 58 Apple 45

The key insight is that water level at any position equals the minimum of maximum heights on both sides minus current height. Best approach is Two Pointers with optimal Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(1)

At each position, scan left to find the maximum height and scan right to find the maximum height. The water trapped at this position is the minimum of these two maximums minus the current height.

Dynamic Programming (Two Pass)

⏱️ Time: O(n) Space: O(n)

Create two arrays: left_max[i] stores maximum height from left up to position i, and right_max[i] stores maximum height from right up to position i. Then calculate trapped water using these precomputed values.

Stack Based Solution

⏱️ Time: O(n) Space: O(n)

Use a stack to keep track of indices of bars in decreasing order of height. When we find a bar higher than the top of stack, we can trap water between them. Pop from stack and calculate the trapped water using the height difference and width.

Two Pointers (Optimal)

⏱️ Time: O(n) Space: O(1)

Start with pointers at both ends. Keep track of max heights seen so far from left and right. Move the pointer with smaller max height inward, calculating trapped water as we go. The key insight is that water level is determined by the smaller of the two boundaries.

Brute Force — Algorithm Steps

For each position i, scan left to find max_left
Scan right to find max_right
Water at i = min(max_left, max_right) - height[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

Position i=4

Current height = 1, scan left for max = 2, scan right for max = 3

Calculate Water

min(max_left=2, max_right=3) - height=1 = 1 unit

Repeat

Do this for every position and sum up

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int solution(int* height, int n) {
    int totalWater = 0;
    
    for (int i = 0; i < n; i++) {
        // Find max height on left
        int maxLeft = 0;
        for (int j = 0; j < i; j++) {
            maxLeft = max(maxLeft, height[j]);
        }
        
        // Find max height on right
        int maxRight = 0;
        for (int j = i + 1; j < n; j++) {
            maxRight = max(maxRight, height[j]);
        }
        
        // Water trapped at position i
        int waterLevel = min(maxLeft, maxRight);
        if (waterLevel > height[i]) {
            totalWater += waterLevel - height[i];
        }
    }
    
    return totalWater;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array - skip '[' and stop at ']'
    int height[1000];
    int n = 0;
    int i = 0;
    
    // Skip initial '['
    while (line[i] && line[i] != '[') i++;
    if (line[i] == '[') i++;
    
    // Parse numbers
    while (line[i] && line[i] != ']') {
        if (line[i] >= '0' && line[i] <= '9') {
            int num = 0;
            while (line[i] >= '0' && line[i] <= '9') {
                num = num * 10 + (line[i] - '0');
                i++;
            }
            height[n++] = num;
        } else {
            i++;
        }
    }
    
    int result = solution(height, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we scan up to n positions left and right

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

1.9M Views

Very High Frequency

~25 min Avg. Time

25.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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler