update 42 java

Author: jim

data/progress.md

@@ -17,7 +17,6 @@
 	 - LC 125 - Valid Palindrome
 	 	- 42
 	 - LC 11 - Container With Most Water
-	 	- 344
 	 	- 42
 	 	- 84
 	 	- 85

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

@@ -43,6 +43,35 @@ public class TrappingRainWater {
 //
 //    }
 
+    // V0-0-1
+    // IDEA: STACK (fixed by gpt)
+    public int trap_0_0_1(int[] height) {
+        int n = height.length;
+        if (n <= 2)
+            return 0;
+
+        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
+            while (!st.isEmpty() && height[i] > height[st.peek()]) {
+                int bottom = st.pop(); // the "valley"
+                if (st.isEmpty())
+                    break; // no left boundary
+
+                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
+
+                ans += width * h;
+            }
+            st.push(i);
+        }
+
+        return ans;
+    }
+
     // V0-1
     // IDEA: 2 POINTER + left_till_array + max_till_array
     /**

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

@@ -2444,5 +2444,89 @@ public int[] searchRange(int[] nums, int target) {
         return res; // ???
     }
 
+    // LC 42
+    // 9.06 - 9.20 am
+    /**
+     *  IDEA 1) 2 pointers + STACK
+     *
+     *   -> left, right pointer
+     *   -> get `area` when `right > left`
+     *   -> sum over all `area` as ans
+     *   -> slide window ???
+     *   -> maintain a window while
+     *     - left <= right
+     *     - otherwise, get `all areas` within window
+     *   - NOT get area at `0 idx`
+     *
+     *   exp 1)
+     *
+     *   Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
+     *   Output: 6
+     *
+     *
+     *   [0,1,0,2,1,0,1,3,2,1,2,1]  ans = 0
+     *    x
+     *
+     *   [0,1,0,2,1,0,1,3,2,1,2,1]  ans = 0, st = [1], max_l = 1
+     *      x
+     *
+     *   [0,1,0,2,1,0,1,3,2,1,2,1]  ans = 0, st = [1,0], max_l = 1
+     *        x
+     *
+     *  [0,1,0,2,1,0,1,3,2,1,2,1]  ans = 0,  2 > max_l, st = [], ans = (left_l - cur_hight * 1 ) = 1
+     *         x
+     *
+     */
+    public int trap(int[] height) {
+        // edge
+        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<>();
+
+        // 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);
+                st.add(val);
+            }
+            // case 2) cur val < l_height
+            else if (val < st_left_height.peek()){
+                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 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);
+            }
+        }
+
+        return ans;
+    }
+
 
 }