Trapping Rain Water Problem in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main goal of the Trapping Rain Water Problem?

To find how much water can be trapped between bars of different heights after raining.

beginner

What does the 'left max' array represent in the Trapping Rain Water Problem?

It stores the highest bar height from the left up to each position.

intermediate

Why do we use both 'left max' and 'right max' arrays in the Trapping Rain Water Problem?

Because the water trapped at each bar depends on the tallest bars on both its left and right sides.

intermediate

What is the time complexity of the efficient solution using two arrays for the Trapping Rain Water Problem?

O(n), where n is the number of bars, because we traverse the array a few times linearly.

advanced

Explain the two-pointer approach for solving the Trapping Rain Water Problem.

Use two pointers at start and end, move the smaller height pointer inward, update max heights, and calculate trapped water on the fly without extra arrays.

In the Trapping Rain Water Problem, what determines the water trapped at a given bar?

A Minimum of highest bars on left and right minus current bar height

B Maximum of highest bars on left and right minus current bar height

C Sum of highest bars on left and right minus current bar height

D Current bar height only

Water trapped depends on the smaller of the tallest bars on both sides minus the current bar height.

What is the space complexity of the solution using left max and right max arrays?

A O(n^2)

B O(1)

C O(n)

D O(log n)

We use two extra arrays of size n, so space complexity is O(n).

Which approach reduces space complexity to O(1) in the Trapping Rain Water Problem?

A Sorting bars

B Brute force

C Using left max and right max arrays

D Two-pointer approach

The two-pointer approach calculates trapped water without extra arrays, using constant space.

If the input heights are [3, 0, 2, 0, 4], how much water is trapped?

A 7

B 4

C 5

D 6

Water trapped is 3 units at index 1, 2 units at index 2, and 1 unit at index 3, total 6.

What is the first step in the two-pointer approach?

A Calculate left max array

B Initialize left and right pointers at array ends

C Calculate right max array

D Sort the array

We start with two pointers at the start and end of the array.

Describe how to calculate trapped water using the left max and right max arrays.

Think about the tallest bars on both sides of each bar.

Explain the two-pointer approach to solve the Trapping Rain Water Problem and why it is efficient.

Focus on how pointers move and how trapped water is calculated step-by-step.

Practice

1. What does the Trapping Rain Water problem ask you to find given an array of heights?

easy

A. The minimum height of the bars

B. The maximum height of the bars

C. The total amount of water that can be trapped between the bars after raining

D. The number of bars in the array

Solution

1. Step 1: Understand the problem context

   The problem gives an array representing heights of bars and asks how much water can be trapped between them after rain.

2. Step 2: Identify the goal

   The goal is to calculate the total volume of trapped water, not just heights or counts.

3. Final Answer:

   The total amount of water trapped between bars -> Option C

4. Quick Check:

   Trapping Rain Water = Total trapped water [OK]

Hint: Think of bars as walls holding water in gaps [OK]

Common Mistakes:

• Confusing trapped water with bar heights
• Counting bars instead of water volume
• Ignoring gaps between bars

2. Which of the following Go code snippets correctly initializes an integer slice to represent bar heights for the Trapping Rain Water problem?

easy

A. heights := new int[6]{4, 2, 0, 3, 2, 5}

B. heights := int[]{4, 2, 0, 3, 2, 5}

C. heights := [6]int{4, 2, 0, 3, 2, 5}

D. heights := []int{4, 2, 0, 3, 2, 5}

Solution

1. Step 1: Recall Go slice initialization syntax

   In Go, slices are initialized with []int{values}, arrays with [size]int{values}.

2. Step 2: Identify correct slice syntax

   heights := []int{4, 2, 0, 3, 2, 5} uses []int{...} which is correct for a slice. heights := [6]int{4, 2, 0, 3, 2, 5} is an array, also valid but less flexible.

3. Final Answer:

   heights := []int{4, 2, 0, 3, 2, 5} -> Option D

4. Quick Check:

   Slice syntax = []int{...} [OK]

Hint: Use []int{} for slices, [n]int{} for arrays [OK]

Common Mistakes:

• Using int[] like in other languages
• Trying to use new keyword for slices
• Confusing arrays and slices syntax

3. What is the output of the following Go code snippet that calculates trapped rain water?

package main
import "fmt"
func trap(height []int) int {
    left, right := 0, len(height)-1
    leftMax, rightMax := 0, 0
    water := 0
    for left < right {
        if height[left] < height[right] {
            if height[left] >= leftMax {
                leftMax = height[left]
            } else {
                water += leftMax - height[left]
            }
            left++
        } else {
            if height[right] >= rightMax {
                rightMax = height[right]
            } else {
                water += rightMax - height[right]
            }
            right--
        }
    }
    return water
}
func main() {
    fmt.Println(trap([]int{0,1,0,2,1,0,1,3,2,1,2,1}))
}

medium

A. 6

B. 5

C. 7

D. 8

Solution

1. Step 1: Understand two-pointer approach

   The code uses two pointers moving inward, tracking max heights on left and right to calculate trapped water.

2. Step 2: Trace the example input

   For input [0,1,0,2,1,0,1,3,2,1,2,1], the trapped water calculated by this method is 6 units.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Two-pointer trap water = 6 [OK]

Hint: Use two pointers and track max heights from both ends [OK]

Common Mistakes:

• Not updating max heights correctly
• Adding negative water amounts
• Confusing left and right pointer moves

4. Identify the bug in the following Go code for trapping rain water and select the correct fix:

func trap(height []int) int {
    left, right := 0, len(height)-1
    leftMax, rightMax := 0, 0
    water := 0
    for left <= right {
        if height[left] < height[right] {
            if height[left] > leftMax {
                leftMax = height[left]
            } else {
                water += leftMax - height[left]
            }
            left++
        } else {
            if height[right] > rightMax {
                rightMax = height[right]
            } else {
                water += rightMax - height[right]
            }
            right--
        }
    }
    return water
}

medium

A. Change '>' to '>=' in max height comparisons

B. Change loop condition to 'left < right' instead of 'left <= right'

C. Initialize water to 1 instead of 0

D. Swap left and right pointer initial values

Solution

1. Step 1: Analyze loop condition impact

   The loop uses 'left <= right', which causes double counting when left == right.

2. Step 2: Fix loop condition

   Changing to 'left < right' prevents overlap and corrects water calculation.

3. Final Answer:

   Change loop condition to 'left < right' instead of 'left <= right' -> Option B

4. Quick Check:

   Loop condition fix = 'left < right' [OK]

Hint: Use strict less than in two-pointer loops to avoid overlap [OK]

Common Mistakes:

• Using <= causes double counting
• Changing comparison operators incorrectly
• Incorrect pointer initialization

5. Given the heights array [5, 2, 1, 2, 1, 5], what is the total trapped rain water? Use the two-pointer approach to solve.

hard

A. 10

B. 12

C. 8

D. 14

Solution

1. Step 1: Initialize pointers and max heights

   left=0, right=5, leftMax=0, rightMax=0, water=0.

2. Step 2: Move pointers inward calculating trapped water

   - left=0 (height=5) >= leftMax(0), leftMax=5, left++ - left=1 (2) < right=5 (5), height[left]

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Two-pointer sum water = 10 [OK]

Hint: Sum min(leftMax, rightMax) - height at each step [OK]

Common Mistakes:

• Adding water twice for same positions
• Not updating max heights correctly
• Stopping loop too early