update 84 java, progress

Author: jim

README.md

@@ -1159,7 +1159,7 @@
 011| [Container With Most Water](https://leetcode.com/problems/container-with-most-water/)|[Python](./leetcode_python/Greedy/container-with-most-water.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Greedy/ContainerWithMostWater.java) | _O(n)_ | _O(1)_ | Medium |Curated Top 75, good basics, `two pointers`,`fb`, amazon|  OK*** (3) (but again !!)
 045| [Jump Game II](https://leetcode.com/problems/jump-game-ii/)|[Python](./leetcode_python/Greedy/jump-game-ii.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Greedy/JumpGame2.java)  | _O(n)_ | _O(1)_| Medium|Greedy, google, apple, fb, tesla, `amazon`| AGAIN******** (4) (MUST)
 055| [Jump Game](https://leetcode.com/problems/jump-game/) |[Python](./leetcode_python/Greedy/jump-game.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Greedy/JumpGame.java)  | _O(n)_ | _O(1)_| Medium|Curated Top 75, good trick, backtrack, Greedy, DP, `amazon`| AGAIN******** (8)
-84| [Largest Rectangle in Histogram](https://leetcode.com/problems/largest-rectangle-in-histogram/)|[Python](./leetcode_python/Greedy/largest-rectangle-in-histogram.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Stack/LargestRectangleInHistogram.java)| _O(n)_ | _O(1)_| Hard |top 100 like, brute force, divide and conquer, good trick, `mono stack`, LC 085, amazon, fb| AGAIN**** (2)
+84| [Largest Rectangle in Histogram](https://leetcode.com/problems/largest-rectangle-in-histogram/)|[Python](./leetcode_python/Greedy/largest-rectangle-in-histogram.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Stack/LargestRectangleInHistogram.java)| _O(n)_ | _O(1)_| Hard |top 100 like, brute force, good trick, `mono stack`, LC 085, amazon, fb| AGAIN******** (3)
 122| [Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/)| [Python](./leetcode_python/Greedy/best-time-to-buy-and-sell-stock-ii.py),  [Java](./leetcode_java/src/main/java/LeetCodeJava/Greedy/BestTimeToBuyAndSellStock2.java) | _O(n)_ | _O(1)_ | Easy |compare with `#309 Best Time to Buy and Sell Stock with Cooldown `, `#714 Best Time to Buy and Sell Stock with Transaction Fee`, `amazon`| again* (2)
 134| [Gas Station](https://leetcode.com/problems/gas-station/)| [Python](./leetcode_python/Greedy/gas-station.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Greedy/GasStation.java)   | _O(n)_ | _O(1)_ | Medium|trick, greedy,`amazon`| AGAIN****** (5)
 135| [Candy](https://leetcode.com/problems/candy/)| [Python](./leetcode_python/Greedy/candy.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Greedy/Candy.java)   | _O(n)_ | _O(1)_ | Hard|LC 123, greedy, boundary, array, `amazon`| AGAIN (2)

leetcode_java/src/main/java/LeetCodeJava/Stack/LargestRectangleInHistogram.java

@@ -47,8 +47,123 @@ public class LargestRectangleInHistogram {
 //    }
 
     // V0-0-1
-    // IDEA: BRUTE FORCE (TLE)
+    // IDEA: MONO STACK (GPT)
+    //       -> STACK (monotonic stack) + pop when (cur_height < last+height)
+    /**
+     *  IDEA:
+     *
+     *  🔑 Takeaways:
+     * 	•	Stack stores indices, not heights — needed to compute width.
+     * 	•	Height comes from the popped index.
+     * 	•	Width is computed from current index minus previous index.
+     * 	•	The dummy 0 is a useful trick to flush the stack at the end.
+     */
+    /**
+     *
+     🧠 Why This Works:
+     •	As long as the current bar is taller or equal, we push its index — since it may be part of a future larger rectangle.
+     •	When the current bar is shorter, we know:
+     •	All previous taller bars can’t extend past this point,
+     •	So we pop them, calculate area, and move on.
+     *
+     */
     public int largestRectangleArea_0_0_1(int[] heights) {
+        int n = heights.length;
+
+        /**
+         *  NOTE !!!!
+         *
+         *  - A monotonic increasing stack to store the `indices` of bars.
+         * 	- We’ll use this to track the left boundaries of rectangles.
+         *
+         *
+         * 	NOTE !!!
+         *
+         * 	 the stack stores the `index` of bars (small -> big)
+         *
+         * 	 -> The stack stores indices of elements in non-decreasing height order
+         * 	 (i.e., from shortest to tallest) as we move left to right.
+         */
+        Stack<Integer> stack = new Stack<>();
+        int maxArea = 0;
+
+        // Append a 0 to flush out remaining stack at end
+        /**
+         *
+         * 	- We’re looping from i = 0 to i = n inclusive.
+         *
+         * 	- At i = n, we use a dummy bar of height 0 to
+         * 	  flush the stack — this ensures we process
+         * 	  all remaining bars.
+         */
+        for (int i = 0; i <= n; i++) {
+
+            /**
+             * NOTE !!!!
+             *
+             * 	- If we’re at i == n, we use height 0 (virtual bar).
+             * 	   - Otherwise, we get the real bar height.
+             *
+             * 	- This trick helps to pop all remaining bars in the
+             *   	stack by triggering the while condition.
+             *
+             */
+            int currHeight = (i == n) ? 0 : heights[i];
+
+            /**
+             * 	- While the current height is `less` than the height at
+             * 	  the `top` of the stack:
+
+             * 	   - We’ve found the right boundary for a rectangle with
+             * 	     `height heights[stack.peek()]`.
+             *
+             * 	   - Now compute area using that height.
+             *
+             */
+            while (!stack.isEmpty() && currHeight < heights[stack.peek()]) {
+
+                /**
+                 *  NOTE !!!
+                 *
+                 * 	- Pop the top index from the stack, and get its height.
+                 * 	- This is the `height` of the rectangle we’re evaluating.
+                 */
+                int height = heights[stack.pop()]; // NOTE !!! we pop the element from stack
+
+                /**
+                 *  NOTE !!!
+                 *
+                 *  - Compute the width of the rectangle:
+                 *
+                 * 	   - If the stack is empty after popping,
+                 * 	       it means the popped bar is the smallest so far,
+                 * 	       so its width spans from index 0 to i - 1 → width = i.
+                 *
+                 * 	   - Otherwise, the left boundary is the new stack.peek(),
+                 * 	      so width is from stack.peek() + 1 to i - 1.
+                 *
+                 */
+                int width = stack.isEmpty() ? i : i - stack.peek() - 1;
+
+                // Compute area and update maxArea if it’s larger.
+                maxArea = Math.max(maxArea, height * width);
+            }
+
+            /**
+             *
+             * 	- Push the current index onto the stack.
+             * 	- This keeps the indices of bars in `non-decreasing` height order.
+             */
+            stack.push(i);
+        }
+
+        return maxArea;
+    }
+
+
+    // V0-0-2
+    // IDEA: BRUTE FORCE (TLE)
+    public int largestRectangleArea_0_0_2(int[] heights) {
         // edge
         if (heights == null || heights.length == 0) {
             return 0;
@@ -73,7 +188,8 @@ public int largestRectangleArea_0_0_1(int[] heights) {
     }
 
     // V0-1
-    // IDEA : STACK (monotonic stack)
+    // IDEA : STACK (monotonic stack) + pop when (cur_height < last+height)
+    // mono increasing stack, but the popping condition is current height < height at stack top.
     // https://leetcode.com/problems/largest-rectangle-in-histogram/editorial/
     /**
      *
@@ -189,119 +305,6 @@ public int largestRectangleArea_1(int[] heights) {
         return maxArea;
     }
 
-    // V0-2
-    // IDEA: MONO STACK (GPT)
-    /**
-     *  IDEA:
-     *
-     *  🔑 Takeaways:
-     * 	•	Stack stores indices, not heights — needed to compute width.
-     * 	•	Height comes from the popped index.
-     * 	•	Width is computed from current index minus previous index.
-     * 	•	The dummy 0 is a useful trick to flush the stack at the end.
-     */
-    /**
-     *
-     🧠 Why This Works:
-     •	As long as the current bar is taller or equal, we push its index — since it may be part of a future larger rectangle.
-     •	When the current bar is shorter, we know:
-     •	All previous taller bars can’t extend past this point,
-     •	So we pop them, calculate area, and move on.
-     *
-     */
-    public int largestRectangleArea_0_2(int[] heights) {
-        int n = heights.length;
-
-        /**
-         *  NOTE !!!!
-         *
-         *  - A monotonic increasing stack to store the `indices` of bars.
-         * 	- We’ll use this to track the left boundaries of rectangles.
-         *
-         *
-         * 	NOTE !!!
-         *
-         * 	 the stack stores the `index` of bars (small -> big)
-         *
-         * 	 -> The stack stores indices of elements in non-decreasing height order
-         * 	 (i.e., from shortest to tallest) as we move left to right.
-         */
-        Stack<Integer> stack = new Stack<>();
-        int maxArea = 0;
-
-        // Append a 0 to flush out remaining stack at end
-        /**
-         *
-         * 	- We’re looping from i = 0 to i = n inclusive.
-         *
-         * 	- At i = n, we use a dummy bar of height 0 to
-         * 	  flush the stack — this ensures we process
-         * 	  all remaining bars.
-         */
-        for (int i = 0; i <= n; i++) {
-
-            /**
-             * NOTE !!!!
-             *
-             * 	- If we’re at i == n, we use height 0 (virtual bar).
-             * 	   - Otherwise, we get the real bar height.
-             *
-             * 	- This trick helps to pop all remaining bars in the
-             *   	stack by triggering the while condition.
-             *
-             */
-            int currHeight = (i == n) ? 0 : heights[i];
-
-            /**
-             * 	- While the current height is `less` than the height at
-             * 	  the `top` of the stack:
-
-             * 	   - We’ve found the right boundary for a rectangle with
-             * 	     `height heights[stack.peek()]`.
-             *
-             * 	   - Now compute area using that height.
-             *
-             */
-            while (!stack.isEmpty() && currHeight < heights[stack.peek()]) {
-
-                /**
-                 *  NOTE !!!
-                 *
-                 * 	- Pop the top index from the stack, and get its height.
-                 * 	- This is the `height` of the rectangle we’re evaluating.
-                 */
-                int height = heights[stack.pop()]; // NOTE !!! we pop the element from stack
-
-                /**
-                 *  NOTE !!!
-                 *
-                 *  - Compute the width of the rectangle:
-                 *
-                 * 	   - If the stack is empty after popping,
-                 * 	       it means the popped bar is the smallest so far,
-                 * 	       so its width spans from index 0 to i - 1 → width = i.
-                 *
-                 * 	   - Otherwise, the left boundary is the new stack.peek(),
-                 * 	      so width is from stack.peek() + 1 to i - 1.
-                 *
-                 */
-                int width = stack.isEmpty() ? i : i - stack.peek() - 1;
-
-                // Compute area and update maxArea if it’s larger.
-                maxArea = Math.max(maxArea, height * width);
-            }
-
-            /**
-             *
-             * 	- Push the current index onto the stack.
-             * 	- This keeps the indices of bars in `non-decreasing` height order.
-             */
-            stack.push(i);
-        }
-
-        return maxArea;
-    }
-
     // V0-3
     // IDEA: BRUTE FORCE (TLE)
     public int largestRectangleArea_0_3(int[] heights) {

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

@@ -2538,9 +2538,42 @@ else if (val < l_height){
      *
      *  IDEA 2) BRUTE FORCE
      */
-    // IDEA 1) MONO STACK ???
+    // IDEA 1) MONO INCREASING STACK ???
     public int largestRectangleArea(int[] heights) {
-        return 0;
+        // edge
+        if(heights.length == 0){
+            return 0;
+        }
+        if(heights.length == 1){
+            return heights[0];
+        }
+
+        int ans = 0;
+
+        // mono increasing stack
+        Stack<Integer> st = new Stack();
+
+        for(int i = 0; i < heights.length; i++){
+            int val = heights[i];
+            /**
+             *  if cur val > `stack top val`
+             *   -> pop val from stack
+             *   -> get `area`
+             *
+             */
+            ans = Math.max(ans, val);
+
+            while(!st.isEmpty() && st.peek() < val){
+                int last_idx = st.pop();
+                int tmp = Math.min(heights[last_idx], val) * (i -  last_idx + 1);
+                System.out.println(">>> i = " + i + ", last_idx = " + last_idx + ", st = " + st + ", tmp = " + tmp);
+                ans = Math.max(ans, tmp);
+            }
+
+            st.add(i); // add idx to stack
+        }
+
+        return ans;
     }