Trapping Rain Water - Practice Coding Problems

Trapping Rain Water - Problem

Imagine you're an architect designing a system to collect rainwater in a cityscape with varying building heights. You have an elevation map represented by an array of non-negative integers, where each integer represents the height of a building and each building has a uniform width of 1 unit.

After it rains, water gets trapped between the buildings, forming pools. Your task is to calculate the total amount of rainwater that can be trapped in this urban landscape.

Goal: Given an array of heights, return the total units of water that can be trapped.

Example: For heights [0,1,0,2,1,0,1,3,2,1,2,1], water gets trapped between buildings, and the total trapped water is 6 units.

Input & Output

example_1.py — Standard Case

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

› Output: 6

💡 Note: The elevation map traps water in valleys: 1 unit at index 2, 1 unit at index 5, 2 units at index 6, 1 unit at index 8, and 1 unit at index 9. Total = 6 units.

example_2.py — Simple Valley

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

› Output: 7

💡 Note: Water gets trapped at indices 1 and 3. At index 1: min(3,4) - 0 = 3 units. At index 3: min(2,4) - 0 = 2 units. Total = 5 units. Wait, let me recalculate: At index 1: min(3,4) - 0 = 3. At index 2: min(3,4) - 2 = 1. At index 3: min(3,4) - 0 = 3. Total = 7 units.

example_3.py — No Water Trapped

$ Input: [1,2,3,4,5]

› Output: 0

💡 Note: This is a monotonically increasing sequence, so no water can be trapped. Water would flow off to the left side.

Visualization

Tap to expand

Understanding the Visualization

Identify the Landscape

We have buildings of different heights creating valleys and peaks

Rain Falls

Water falls uniformly across the entire landscape

Water Settles

Water gets trapped in valleys between buildings, filling up to the level where it would overflow

Calculate Volume

For each position, water level = min(max_left_height, max_right_height)

Key Takeaway

🎯 Key Insight: Water level at any position is limited by the shorter of the tallest barriers on its left and right sides. The two-pointer technique elegantly exploits this by always moving from the side with the smaller maximum height.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three separate O(n) passes through the array

✓ Linear Growth

Space Complexity

O(n)

Two additional arrays to store left and right maximum heights

⚡ Linearithmic Space

Constraints

n == height.length
1 ≤ n ≤ 2 × 10⁴
0 ≤ height[i] ≤ 3 × 10⁴
Follow-up: Can you solve it in O(1) extra space?

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 25 Apple 18

The optimal solution uses the two pointers technique with O(n) time and O(1) space complexity. Key insight: move the pointer from the side with the smaller maximum height, as water level is determined by the minimum of left and right maximums. The dynamic programming approach is also optimal in time but uses O(n) extra space to pre-compute maximum heights.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Pre-compute Max Heights)	O(n)	O(n)	Pre-compute maximum heights for left and right sides, then calculate trapped water in one pass
Brute Force (For Each Position Find Boundaries)	O(n²)	O(1)	For each position, scan left and right to find maximum heights, then calculate trapped water
Two Pointers (Optimal Space)	O(n)	O(1)	Use two pointers moving inward, always advancing from the side with lower maximum height

Dynamic Programming (Pre-compute Max Heights) — Algorithm Steps

Create arrays to store left maximum and right maximum for each position
First pass: compute maximum height to the left of each position
Second pass: compute maximum height to the right of each position
Third pass: calculate trapped water using min(left_max[i], right_max[i]) - height[i]

Visualization

Tap to expand

Step-by-Step Walkthrough

Compute Left Max

For each position, store the maximum height seen so far from the left

Compute Right Max

For each position, store the maximum height seen so far from the right

Calculate Water

For each position, trapped water = min(left_max, right_max) - current_height

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 trap(int* height, int heightSize) {
    if (height == NULL || heightSize < 3) {
        return 0;
    }
    
    int* leftMax = (int*)malloc(heightSize * sizeof(int));
    int* rightMax = (int*)malloc(heightSize * sizeof(int));
    
    // Compute left maximum for each position
    leftMax[0] = height[0];
    for (int i = 1; i < heightSize; i++) {
        leftMax[i] = max(leftMax[i-1], height[i]);
    }
    
    // Compute right maximum for each position
    rightMax[heightSize-1] = height[heightSize-1];
    for (int i = heightSize-2; i >= 0; i--) {
        rightMax[i] = max(rightMax[i+1], height[i]);
    }
    
    // Calculate trapped water
    int totalWater = 0;
    for (int i = 0; i < heightSize; i++) {
        int waterLevel = min(leftMax[i], rightMax[i]);
        if (waterLevel > height[i]) {
            totalWater += waterLevel - height[i];
        }
    }
    
    free(leftMax);
    free(rightMax);
    return totalWater;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int height[1000];
    int size = 0;
    char* token = strtok(input, "[,]\n");
    while (token != NULL) {
        height[size++] = atoi(token);
        token = strtok(NULL, "[,]\n");
    }
    
    printf("%d\n", trap(height, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three separate O(n) passes through the array

✓ Linear Growth

Space Complexity

O(n)

Two additional arrays to store left and right maximum heights

⚡ Linearithmic Space

Constraints

n == height.length
1 ≤ n ≤ 2 × 10⁴
0 ≤ height[i] ≤ 3 × 10⁴
Follow-up: Can you solve it in O(1) extra space?

42.4K Views

Very High Frequency

~18 min Avg. Time

1.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Pre-compute Max Heights) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler