update 42 java, readme

Author: jim

README.md

@@ -812,7 +812,7 @@
 |  #  | Title           |  Solution       |  Time           | Space           | Difficulty    | Note          | Status| 
 |-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------|-----|
 019| [Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/)| [Python](./leetcode_python/Two_Pointers/remove-nth-node-from-end-of-list.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/LinkedList/RemoveNthNodeFromEndOfList.java) | _O(n)_   | _O(1)_ | Medium |Curated Top 75, good basic, MUST, `linked list`,`two pointers`,`fb`| AGAIN********** (4) (MUST)
-042 | [Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/) | [Python](./leetcode_python/Two_Pointers/trapping-rain-water.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/TwoPointer/TrappingRainWater.java) || | Hard |scan, dp, trick, two pointer, `amazon`, `apple`|  AGAIN*** (2) (not start)
+042 | [Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/) | [Python](./leetcode_python/Two_Pointers/trapping-rain-water.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/TwoPointer/TrappingRainWater.java) || | Hard |stack, prefix-suffix array, brute force, two pointer, `amazon`, `apple`|  AGAIN******** (3)
 086| [Partition List](https://leetcode.com/problems/partition-list/)| [Python](./leetcode_python/Two_Pointers/partition-list.py) | _O(n)_       | _O(1)_         | Medium         || OK* 
 141| [Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/)| [Python](./leetcode_python/Two_Pointers/linked-list-cycle.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/TwoPointer/LinkedListCycle.java) | _O(n)_ | _O(1)_ | Easy |Curated Top 75, `basic`,`amazon`, `fb`, linked list, 2 pointers, check #142|  OK** (5)
 142| [Linked List Cycle II](https://leetcode.com/problems/linked-list-cycle-ii/)| [Python](./leetcode_python/Two_Pointers/linked-list-cycle-ii.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/TwoPointer/LinkedListCycle2.java) | _O(n)_ | _O(1)_   | Medium   |linked list, 2 pointers, check #141| AGAIN****** (4) (again!)

leetcode_java/src/main/java/LeetCodeJava/TwoPointer/TrappingRainWater.java

@@ -45,24 +45,86 @@ public class TrappingRainWater {
 
     // V0-0-1
     // IDEA: STACK (fixed by gpt)
+    /**
+     *  Example:
+     *
+     *    height = [0,1,0,2]
+     *
+     *    Steps:
+     * 	1.	i=0 → push 0.
+     * 	2.	i=1 → height[1]=1 > height[0]=0 → pop valley 0.
+     * 	    •	Left boundary doesn’t exist (stack empty) → break.
+     * 	    •	Push 1.
+     * 	3.	i=2 → height[2]=0 not > height[1]=1 → push 2.
+     * 	4.	i=3 → height[3]=2 > height[2]=0.
+     * 	    •	Pop valley 2. Left boundary = 1.
+     * 	    •	Width = 3-1-1=1.
+     * 	    •	Height = min(2,1)-0=1.
+     * 	    •	Water = 1*1=1.
+     * 	    •	Continue: height[3]=2 > height[1]=1.
+     * 	    •	Pop valley 1. Stack empty → break.
+     * 	    •	Push 3.
+     *
+     *
+     *  -> Result = 1. ✅
+     *
+     */
     public int trap_0_0_1(int[] height) {
         int n = height.length;
         if (n <= 2)
             return 0;
 
+        /**
+         * 	- ans = result (total trapped water).
+         *
+         * 	- st = stack to store indices (not heights directly).
+         * 	    - Storing indices allows us to compute both height and width.
+         */
         int ans = 0;
         Stack<Integer> st = new Stack<>(); // store indices
 
         for (int i = 0; i < n; i++) {
             // Process while current height is greater than the stack top
+            /**
+             *  NOTE !!
+             *
+             *  - While stack is not empty and the current bar (height[i])
+             *    is taller than the bar at the top index (height[st.peek()]):
+             *
+             * 	- We found a right boundary for a trapped water “basin.” (盆地)
+             *
+             */
             while (!st.isEmpty() && height[i] > height[st.peek()]) {
+                /**
+                 *
+                 * 	- Pop the index at the top.
+                 *  - This represents the `valley` bottom between two walls.
+                 */
                 int bottom = st.pop(); // the "valley"
                 if (st.isEmpty())
                     break; // no left boundary
 
+                /**
+                 * 	- The new top of stack is the left boundary index.
+                 */
                 int left = st.peek(); // left boundary index
                 int width = i - left - 1; // distance between left and right walls
-                int h = Math.min(height[left], height[i]) - height[bottom]; // bounded height
+                /**
+                 *  NOTE !!!
+                 *
+                 * - Effective water height =
+                 *    shorter of the `two walls` (left and right) minus the valley’s height.
+                 *
+                 * - This ensures we don’t over-count if one wall is shorter.
+                 *
+                 *
+                 * -> `eff` height = min (left_wall_height, right_wall_height)
+                 *
+                 *    e.g. Math.min( height[left], height[i] ) - height[bottom]
+                 *
+                 *    (NOTE !!!  need to SUBTRACT the `bottom` height)
+                 */
+                int h = Math.min( height[left], height[i] ) - height[bottom]; // bounded height
 
                 ans += width * h;
             }
@@ -153,7 +215,7 @@ public int trap_0_1(int[] height) {
 
     // V1-1
     // https://neetcode.io/problems/trapping-rain-water
-    // IDEA: BRUTE FORCE
+    // IDEA: BRUTE FORCE - `leftMax, rightMax array`
     public int trap_1_1(int[] height) {
         if (height == null || height.length == 0) {
             return 0;

leetcode_java/src/main/java/dev/workspace14.java

@@ -2482,46 +2482,41 @@ public int trap(int[] height) {
         if(height.length <= 2){
             return 0;
         }
-//        // ??
-//        if(height.length == 3){
-//            return 0;
-//        }
-
         int ans = 0;
         Stack<Integer> st = new Stack<>();
         //int l = 0;
         //int r = 0;
 
-        //int l_height = Integer.MAX_VALUE; // ???
-        Stack<Integer> st_left_height = new Stack<>();
+        int l_height = Integer.MAX_VALUE; // ???
+        //Stack<Integer> st_left_height = new Stack<>();
 
         // NOTE !!! idx starts from 1
         for(int r = 1; r < height.length; r++){
             int val = height[r];
             // case 1) st is empty
             if(st.isEmpty()){
-                //l_height = val;
-                st_left_height.add(val);
+                l_height = val;
+                //st_left_height.add(val);
                 st.add(val);
             }
             // case 2) cur val < l_height
-            else if (val < st_left_height.peek()){
-                st_left_height.add(val);
+            else if (val < l_height){
+                //st_left_height.add(val);
                 st.add(val);
             }
             // case 3) cur val > l_height
             else{
                 // get `area`
                 while(!st.isEmpty()){
                     // pop `1st element` from st_left_height
-                    int l_height = st_left_height.pop();
+                    //int l_height = st_left_height.pop();
                     //int tmp = st.pop() * l_height;
                     ans += (st.pop() * l_height);
                 }
                 // add cur val to st
                 st.add(val);
-               // l_height = val;
-                st_left_height.add(val);
+                l_height = val;
+                //st_left_height.add(val);
             }
         }