Update stack problem notes

Author: enginebai

leetcode/1004.max-consecutive-ones-iii.md

@@ -34,18 +34,26 @@ fun longestOnes(nums: IntArray, k: Int): Int {
     var right = 0
     var zeroCount = 0
     var maxLength = 0
-    while (right < nums.size) {
+    for (right in nums.indices) {
         if (nums[right] == 0) zeroCount++
         while (zeroCount > k) {
             if (nums[left] == 0) zeroCount--
             left++
         }
         maxLength = maxOf(maxLength, right - left + 1)
-        right++
     }
     return maxLength
 }
 ```
 
 * **Time Complexity**: `O(n)`.
-* **Space Complexity**: `O(1)`.
+* **Space Complexity**: `O(1)`.
+
+## Dynamic Programming
+`dp[i][k]` represents the longest substring of `1's` ending at index `i` with at most `k` zeros.
+
+And the state transition is:
+* If `nums[i] == 1`, `dp[i][k] = dp[i - 1][k] + 1`.
+* If `nums[i] == 0`, `dp[i][k] = dp[i - 1][k - 1] + 1`.
+
+* **Time Complexity**: `O(n * k)`.

leetcode/1021.remove-outermost-parentheses.md

@@ -2,8 +2,8 @@
 
 ## Counting
 We maintain a left parenthsis count, it will be the outermost when:
-1. It's the first left parenthsis. it's the left parenthsis that makes the count to 1.
-2. It's the last left parenthsis, it's the right parenthsis that makes the count to 0.
+1. It's the first left parenthsis. it's the left parenthsis that makes the count `0 -> 1`.
+2. It's the last left parenthsis, it's the right parenthsis that makes the count `1 -> 0`.
 
 If it's not the outermost, we append it to the result.
 ```kotlin
@@ -12,11 +12,11 @@ fun removeOuterParentheses(s: String): String {
     val result = StringBuilder()
     for (c in s) {
         if (c == '(') {
-            if (leftCount != 0) result.append(c.toString())
+            if (leftCount > 0) result.append(c.toString())
             leftCount++
         } else {
             leftCount--
-            if (leftCount != 0) result.append(c.toString())
+            if (leftCount > 0) result.append(c.toString())
         }
     }
     return result.toString()

leetcode/1190.reverse-substrings-between-each-pair-of-parentheses.md

@@ -1,20 +1,37 @@
 # [1190. Reverse Substrings Between Each Pair of Parentheses](https://leetcode.com/problems/reverse-substrings-between-each-pair-of-parentheses/)
 
+The problem is to reverse the string between each pair of parentheses.
+```js
+(u(love)i)
+(u evol i)
+  iloveu
+```
+
+## Breakdowns
+> 1. If we don't have nested parentheses `s = "(abc)def(ghi)"`?
+
+We can simply identify the substrings inside `()`, reverse it and remove the parentheses.
+
 ## Stack
-We use stack for the nested structure and reverse the string between each pair of parentheses.
+We use stack for the nested structure and reverse the string when encountering the `)` parentheses:
+1. Push the character to the stack until we encounter `)`.
+2. When we encounter `)`, we pop the characters from the stack until we encounter `(`.
+3. **Reverse the string** and push back to the stack.
+4. Continue until the end of the string, then concatenate the stack contents.
+
 ```js
 s = "((ab)z)i"
          *
 stack = (, (, a, b
 
-// We pop b, a to form "ba" and push back to stack
+// We pop `b`, `a` to form "ba" and push back to stack
 stack = (, ba
 
 s = "((ab)z)i"
            *
 stack = (, ba, z
 
-// We pop z, ba to form "zab" and push back to stack
+// We pop `z`, `ba` to form "zab" and push back to stack
 stack = zab
 
 s = "((ab)z)i"
@@ -25,6 +42,28 @@ stack = zab, i
 return "zabi"
 ```
 
+There is a common pitfall that we forget to **reverse the string when poping from the stack**.
+
+```js
+s = "(u(love)i)"
+            *
+stack = (, u, (, l, o, v, e, )
+
+// We pop `e`, `v`, `o`, `l` to form "evol" and push back to stack
+stack = (, u, evol
+
+// Keep iterating the string
+stack = (, u, evol, i, )
+
+// We pop `i`
+stack = (, u, evol,
+temp = i
+
+// We pop `evol`, `u` to form "iloveu" and push back to stack
+stack = (, u
+temp = ilove // We should reverse the string when poping `evol` from the stack!!
+```
+
 ```kotlin
 fun reverseParentheses(s: String): String {
     val stack = Stack<String>()
@@ -48,9 +87,52 @@ fun reverseParentheses(s: String): String {
 * **Time Complexity:** `O(n^2)`, we iterate through the string and reverse the string between each pair of parentheses when poping from the stack.
 * **Space Complexity:** `O(n)`
 
+## Two Pointers
 > TODO: There is another solution that traverse the string based on the nested structure:
 > 
 > ```js
 > (ABCDE(FIJKL)MNOPQ)
 > 1 --> 3 <-- 2 --> 4
-> ABCDE, LKJIHF, MNOPQ     
+> ABCDE, LKJIHF, MNOPQ     
+
+
+> The following was copied from ChatGPT, need to verify.
+Instead of a stack, we can use an index-mapping approach to efficiently swap characters:
+1. Use a stack to track opening parentheses indices.
+2. Create an array to store matching parentheses positions.
+3. Use two pointers to process the string in the correct order based on matching indices.
+
+```kotlin
+fun reverseParentheses(s: String): String {
+    val n = s.length
+    val pair = IntArray(n)
+    val stack = ArrayDeque<Int>()
+
+    // Step 1: Build a map of matching parentheses indices
+    for (i in s.indices) {
+        if (s[i] == '(') stack.push(i)
+        if (s[i] == ')') {
+            val j = stack.pop()
+            pair[i] = j
+            pair[j] = i
+        }
+    }
+
+    // Step 2: Process the string using two pointers
+    val result = StringBuilder()
+    var i = 0
+    var direction = 1
+
+    while (i < n) {
+        if (s[i] == '(' || s[i] == ')') {
+            i = pair[i] // Jump to the matching parenthesis
+            direction = -direction // Reverse direction
+        } else {
+            result.append(s[i])
+        }
+        i += direction
+    }
+
+    return result.toString()
+}
+```

leetcode/1249.minimum-remove-to-make-valid-parentheses.md

@@ -1,21 +1,5 @@
 # [1249. Minimum Remove to Make Valid Parentheses](https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/)
 
-## Clarification Questions
-* No, it's clear from problem description.
- 
-## Test Cases
-### Normal Cases
-```
-Input: 
-Output: 
-```
-### Edge / Corner Cases
-* 
-```
-Input: 
-Output: 
-```
-
 ## Stack
 We use stack to match the parentheses, and we store the index when any unmatched parentheses are found.
 ```kotlin
@@ -100,7 +84,6 @@ fun minRemoveToMakeValid(s: String): String {
     }
     var rightCount = 0
     for (i in s.length - 1 downTo 0) {
-        if (toRemove.contains(i)) continue // Remember to skip the invalid left parentheses
         val c = s[i]
         if (c == ')') rightCount++
         else if (c == '(') rightCount--

leetcode/129.sum-root-to-leaf-numbers.md

@@ -35,11 +35,10 @@ For `2 -> 3 -> 5`, we traverse to build the number `235`:
 > Source: https://leetcode.cn/problems/sum-root-to-leaf-numbers/solutions/464666/qiu-gen-dao-xie-zi-jie-dian-shu-zi-zhi-he-by-leetc/
 
 Steps by steps:
-![](../media/129.sum-root-to-leaf-numbers-1.png)
-![](../media/129.sum-root-to-leaf-numbers-2.png)
-![](../media/129.sum-root-to-leaf-numbers-3.png)
-![](../media/129.sum-root-to-leaf-numbers-4.png)
+![](../media/129.sum-root-to-leaf-numbers-0-1.png)
+![](../media/129.sum-root-to-leaf-numbers-0-2.png)
 ```kotlin
+// Bottom-up approach
 fun sumNumbers(root: TreeNode?): Int {
     return dfs(root, 0)
 }
@@ -56,6 +55,25 @@ private fun dfs(root: TreeNode?, num: Int): Int {
     val right = dfs(root.right, newNum)
     return left + right
 }
+
+// Or top-down approach
+private var sum = 0
+
+fun sumNumbers(root: TreeNode?): Int {
+    dfs(root, 0)
+    return sum
+}
+
+private fun dfs(root: TreeNode?, num: Int) {
+    if (root == null) return
+    val newNum = num * 10 + root.`val`
+    if (root.left == null && root.right == null) {
+        sum += newNum
+        return
+    }
+    dfs(root.left, newNum)
+    dfs(root.right, newNum)
+}
 ```
 
 * **Time Complexity:** `O(n)`

leetcode/1405.longest-happy-string.md

@@ -37,9 +37,9 @@ fun longestDiverseString(a: Int, b: Int, c: Int): String {
         if (count[i1] > 0) maxHeap.add(i1)
         if (count[i2] > 0) maxHeap.add(i2)
     }
-    // Append the last one character at most 2 times
     if (maxHeap.isNotEmpty()) {
         val i1 = maxHeap.poll()
+        // Append the last one character at most 2 times
         val c1 = min(count[i1], 2)
         str.append(('a' + i1).toString().repeat(c1))
     }

leetcode/1443.minimum-time-to-collect-all-apples-in-a-tree.md

@@ -15,27 +15,37 @@
 ```
 
 ## DFS
-To find the minimum time to collect all apples, we can use DFS to traverse the tree. We define `dfs(root)` as the time to collect all apples in the subtree rooted at `root`. For each root, we can calculate the time to collect all apples in the subtree (postorder), then add the time to traverse from the root to the subtree if there are apples in the subtree, which is `dfs(root) = dfs(child) + 2` if `dfs(child) > 0` (there are apples in the subtree), or dfs(root) = 0 if `dfs(child) = 0` (there are no apples in the subtree).
+To find the minimum time to collect all apples, we can use DFS to traverse the tree. We define `dfs(root)` as the time to collect all apples in the subtree rooted at `root`. For each root, we can calculate the time to collect all apples in the subtree (postorder), then add the time to traverse from the root to the subtree if there are apples in the subtree. 
+
+```js
+           dfs(root)
+ +2 or 0  /         \ +2 or 0
+    dfs(left)      dfs(right)
+```
+
+`dfs(root)` will be:
+1. The sum of `2 + dfs(child)` if there are apples in the subtree of the child node or the child node itself.
+2. `0` if there are no any apples in the subtree of the child node, including child node itself.
 
 There are several possible cases:
-* There are apples in the subtree: `dfs(root) = 2 + dfs(left) = 2 + 2 = 4`
+* There are apples in the subtree in child node, that is `dfs(left) > 0`, so `dfs(root) = 2 + dfs(left) = 2 + 2 = 4`
 ```js
         dfs(root)
-        /       2
+        /       +2
        X   dfs(left) = 2
      /   \
     O     X
 
         dfs(root)
-        /       2
+        /       +2
        O   dfs(left) = 2
      /   \
     O     X
 ```
-* There are no apples in the subtree, but there is an apple in the left or right child: `dfs(root) = 2 + dfs(left) = 2 + 0 = 2`
+* There are no apples in the subtree of child node `dfs(left) == 0`, but there is an apple in the left or right child: `dfs(root) = 2 + dfs(left) = 2 + 0 = 2`
 ```js
         dfs(root)
-        /       2
+        /       +2
        O   dfs(left) = 0
      /   \
     X     X
@@ -49,7 +59,7 @@ There are several possible cases:
     X     X
 ```
 
-* Root has an apple or not: Here we don't care about if the root has an apple or not, because the time to collect the apple is `0`. And the time to collect the apple in current root will be calculated in the parent node, or `0` for top-level root.
+* Root has an apple or not: Here we **don't care about** if the root has an apple or not, because the time to collect the apple is `0`. And the time to collect the apple in current root will be calculated in the parent node, or `0` for top-level root.
 
 ```kotlin
 fun minTime(n: Int, edges: Array<IntArray>, hasApple: List<Boolean>): Int {
@@ -83,7 +93,7 @@ private fun dfs(
         if (child != parent) {
             val childTime = dfs(tree, child, root, hasApple)
             /**
-             * childTime > 0: There are apples in the subtree
+             * childTime > 0: There are apples in the subtree of child node
              *          root  dfs(root) = 2 + dfs(child) = 4
              *         /    
              *        X       dfs(child) = 2
@@ -98,7 +108,7 @@ private fun dfs(
              */
             if (childTime > 0) {
                 totalTime += childTime + 2
-            } else {
+            } else if (hasApple[child]) {
                 totalTime += 2
             }
         }