Trapping Rain Water Using Stack in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind using a stack to solve the Trapping Rain Water problem?

Use a stack to keep track of bars that are bounded by higher bars on both sides. When a higher bar is found, calculate trapped water using the distance and height difference between bars.

beginner

In the Trapping Rain Water problem, what does each element in the stack represent?

Each element in the stack represents the index of a bar in the elevation map that is waiting to find a right boundary to trap water.

intermediate

Why do we pop from the stack when the current bar height is greater than the height of the bar at the top of the stack?

Because a higher bar on the right can form a boundary to trap water with the bar below the popped bar, allowing calculation of trapped water volume.

intermediate

What is the time complexity of the Trapping Rain Water solution using a stack?

O(n), because each bar is pushed and popped at most once from the stack.

beginner

What happens if the stack is empty when trying to calculate trapped water?

No trapped water can be calculated because there is no left boundary to form a container.

What does the stack store in the Trapping Rain Water problem?

A Distances between bars

B Heights of bars

C Water volumes

D Indices of bars

The stack stores indices of bars to help calculate trapped water using their positions and heights.

When do we calculate trapped water in the stack approach?

A When current bar is lower than top of stack

B When current bar is higher than top of stack

C When stack is empty

D At the end of the array only

Trapped water is calculated when the current bar is higher than the bar at the top of the stack.

What does the distance between bars represent in trapped water calculation?

A Total water volume

B Height of trapped water

C Width of trapped water container

D Stack size

Distance between bars represents the width of the container holding trapped water.

What is the space complexity of the stack solution?

A O(n)

B O(log n)

C O(1)

D O(n^2)

The stack can hold up to n indices, so space complexity is O(n).

If the stack is empty, what does it mean for trapped water calculation?

A No left boundary exists

B Water can be trapped

C Water volume is maximum

D Stack error

An empty stack means no left boundary to trap water.

Explain step-by-step how the stack helps calculate trapped rain water in the elevation map.

Think about how boundaries form containers for water.

Describe why the stack approach is efficient for the Trapping Rain Water problem compared to brute force.

Focus on how the stack reduces repeated work.

Practice

1. What is the main purpose of using a stack in the Trapping Rain Water Using Stack algorithm?

easy

A. To store the total amount of trapped water directly

B. To keep track of bars that are not yet processed for water trapping

C. To sort the heights of bars in ascending order

D. To reverse the array of bar heights

Solution

1. Step 1: Understand the role of stack in the algorithm

   The stack stores indices of bars that are waiting to find a right boundary to trap water.

2. Step 2: Clarify what the stack does not do

   The stack does not store water amounts or sort bars; it helps find boundaries for trapped water.

3. Final Answer:

   To keep track of bars that are not yet processed for water trapping -> Option B

4. Quick Check:

   Stack tracks bars for trapping water [OK]

Hint: Stack holds indices of bars waiting for right boundary [OK]

Common Mistakes:

• Thinking stack stores water volume directly
• Assuming stack sorts the bars
• Believing stack reverses the array

2. Which of the following is the correct way to initialize an empty stack in JavaScript for the trapping rain water problem?

easy

A. const stack = [];

B. const stack = {};

C. const stack = null;

D. const stack = new Stack();

Solution

1. Step 1: Identify the correct data structure for stack in JavaScript

   JavaScript uses arrays as stacks by pushing and popping elements.

2. Step 2: Check each option

   const stack = []; initializes an empty array, which works as a stack. const stack = {}; is an object, not a stack. const stack = null; is null, no stack. const stack = new Stack(); assumes a Stack class which is not built-in.

3. Final Answer:

   const stack = []; -> Option A

4. Quick Check:

   Empty array for stack [OK]

Hint: Use empty array [] as stack in JavaScript [OK]

Common Mistakes:

• Using object {} instead of array
• Assuming Stack class exists by default
• Initializing stack as null

3. What will be the output of the following code snippet that uses stack to calculate trapped rain water?

const height = [0,1,0,2,1,0,1,3,2,1,2,1];
function trap(height) {
  let stack = [];
  let water = 0;
  for (let i = 0; i < height.length; i++) {
    while (stack.length && height[i] > height[stack[stack.length - 1]]) {
      let top = stack.pop();
      if (!stack.length) break;
      let distance = i - stack[stack.length - 1] - 1;
      let boundedHeight = Math.min(height[i], height[stack[stack.length - 1]]) - height[top];
      water += distance * boundedHeight;
    }
    stack.push(i);
  }
  return water;
}
console.log(trap(height));

medium

A. 6

B. 5

C. 7

D. 8

Solution

1. Step 1: Understand the input and algorithm flow

   The input array represents bar heights. The stack-based algorithm calculates trapped water by finding boundaries and distances.

2. Step 2: Trace the code logic mentally

   The code correctly calculates trapped water for the given heights, which is a classic example resulting in 6 units of water trapped.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Classic trapping rain water example = 6 [OK]

Hint: Classic example height array traps 6 units water [OK]

Common Mistakes:

• Miscounting trapped water units
• Ignoring stack empty check
• Wrong distance or bounded height calculation

4. Identify the error in the following code snippet for trapping rain water using stack:

function trap(height) {
  let stack = [];
  let water = 0;
  for (let i = 0; i < height.length; i++) {
    while (stack.length && height[i] >= height[stack[stack.length - 1]]) {
      let top = stack.pop();
      if (!stack.length) break;
      let distance = i - stack[stack.length - 1] - 1;
      let boundedHeight = Math.min(height[i], height[stack[stack.length - 1]]) - height[top];
      water += distance * boundedHeight;
    }
    stack.push(i);
  }
  return water;
}

medium

A. The distance calculation is incorrect

B. The stack should be initialized as an object, not array

C. The comparison should be >, not >= in the while condition

D. The water variable should be reset inside the loop

Solution

1. Step 1: Analyze the while loop condition

   The condition uses >= which causes incorrect popping when heights are equal, leading to wrong trapped water calculation.

2. Step 2: Correct the condition

   Changing >= to > ensures only strictly higher bars trigger popping, preserving correct boundaries.

3. Final Answer:

   The comparison should be >, not >= in the while condition -> Option C

4. Quick Check:

   Use > in while condition to avoid wrong pops [OK]

Hint: Use >, not >=, to avoid popping equal height bars [OK]

Common Mistakes:

• Using >= causes incorrect water calculation
• Initializing stack as object instead of array
• Resetting water inside loop wrongly

5. Given the heights array [4, 2, 0, 3, 2, 5], what is the total trapped rain water calculated using the stack method?

hard

A. 6

B. 7

C. 8

D. 9

Solution

1. Step 1: Visualize the bars and trapped water

   Bars heights: 4,2,0,3,2,5. Water trapped between bars is calculated by stack method considering boundaries and distances.

2. Step 2: Calculate trapped water step-by-step

   Water at index 1: 2, index 2: 4, index 3: 1, index 4: 2, total 9 units.

3. Final Answer:

   9 -> Option D

4. Quick Check:

   Sum trapped water units = 9 [OK]

Hint: Sum water between boundaries carefully for correct total [OK]

Common Mistakes:

• Miscounting trapped water units
• Ignoring zero height bars
• Wrong boundary identification