Add new stack & queue problems

Author: enginebai

leetcode/1021.remove-outermost-parentheses.md

@@ -0,0 +1,54 @@
+# [1021. Remove Outermost Parentheses](https://leetcode.com/problems/remove-outermost-parentheses/description/)
+
+## 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.
+
+If it's not the outermost, we append it to the result.
+```kotlin
+fun removeOuterParentheses(s: String): String {
+    var leftCount = 0
+    val result = StringBuilder()
+    for (c in s) {
+        if (c == '(') {
+            if (leftCount != 0) result.append(c.toString())
+            leftCount++
+        } else {
+            leftCount--
+            if (leftCount != 0) result.append(c.toString())
+        }
+    }
+    return result.toString()
+}
+```
+* **Time Complexity:** `O(n)`, where `n` is the length of the string.
+* **Space Complexity:** `O(1)`, where we don't count the space for the result.
+
+## Stack
+> Might skip this solution, it's overcomplicated.
+```kotlin
+fun removeOuterParentheses(s: String): String {
+    val ans = StringBuilder()
+    val stack = Stack<String>()
+    for (c in s) {
+        if (c == '(') {
+            stack.push(c.toString())
+        } else {
+            val str = LinkedList<String>()
+            while (stack.isNotEmpty() && stack.peek() != "(") {
+                str.addFirst(stack.pop())
+            }
+            stack.pop() // Pop (
+            if (stack.isNotEmpty()) {
+                str.addLast(")")
+                str.addFirst("(") 
+                stack.push(str.joinToString(""))
+            } else { // It's outermost, add current string to answer
+                ans.append(str.joinToString(""))
+            }
+        }
+    }
+    return ans.toString()
+}
+```

leetcode/1047.remove-all-adjacent-duplicates-in-string.md

@@ -1,22 +1,8 @@
-## [1047. Remove All Adjacent Duplicates In String](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/)
-
-## Clarification Questions
-* No, it's clear from problem description.
- 
-## Test Cases
-### Normal Cases
-```
-Input: 
-Output: 
-```
-### Edge / Corner Cases
-* 
-```
-Input: 
-Output: 
-```
+# [1047. Remove All Adjacent Duplicates In String](https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string/)
 
 ## Stack
+We can use stack to remove adjacent duplicates. If the top of the stack is the same as the current character, we pop the top of the stack. Otherwise, we push the current character to the stack.
+
 ```kotlin
 fun removeDuplicates(s: String): String {
     val stack = Stack<Char>()
@@ -27,11 +13,61 @@ fun removeDuplicates(s: String): String {
             stack.push(s[i])
         }
     }
-    val result = StringBuilder()
-    while (!stack.isEmpty()) {
-        result.append(stack.pop())
+    return stack.joinToString("")
+}
+```
+
+* **Time Complexity:** `O(n)`, where n is the length of the string.
+* **Space Complexity:** `O(n)`.
+
+## Two Pointers
+We have read and write pointers. The read pointer reads the characters from the string. The write pointer is the next index to write the character. If the current character is the same as the previous character, we decrease the write pointer. Otherwise, we write the current character to the write pointer.
+
+For example, the read point is at index 2, `s[read] == s[write - 1]` which is adjacent duplicate, so we decrease the write pointer.
+
+```js
+  0 1 2 3 4 5
+  a b b a c a
+      r
+      w
+
+// After
+  0 1 2 3 4 5
+  a b b a c a
+      r
+    w
+
+// At the end of iteration
+  0 1 2 3 4 5
+  c a b a c a // We have overwritten the string at index 0 and 1.
+              r
+      w 
+
+// Return the substring from 0 to write pointer
+  0 1 2 3 4 5
+  c a
+               r
+      w
+```
+
+```kotlin
+fun removeDuplicates(s: String): String {
+    val c = s.toCharArray()
+    val n = s.length
+    var read = 1
+    var write = 1
+    while (read < n) {
+        if (write - 1 >= 0 && c[read] == c[write - 1]) {
+            write--
+        } else {
+            c[write] = c[read]
+            write++
+        }
+        read++
     }
-    result.reverse()
-    return result.toString()
+    return c.concatToString(0, write)
 }
-```
+```
+
+* **Time Complexity:** `O(n)`, where n is the length of the string.
+* **Space Complexity:** `O(n)` for converting the string to char array.

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

@@ -0,0 +1,56 @@
+# [1190. Reverse Substrings Between Each Pair of Parentheses](https://leetcode.com/problems/reverse-substrings-between-each-pair-of-parentheses/)
+
+## Stack
+We use stack for the nested structure and reverse the string between each pair of parentheses.
+```js
+s = "((ab)z)i"
+         *
+stack = (, (, a, b
+
+// 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
+stack = zab
+
+s = "((ab)z)i"
+            *
+stack = zab, i
+
+// Then we join the stack to form the result
+return "zabi"
+```
+
+```kotlin
+fun reverseParentheses(s: String): String {
+    val stack = Stack<String>()
+    for (c in s) {
+        if (c == '(') {
+            stack.push(c.toString())
+        } else if (c == ')') {
+            val builder = StringBuilder()
+            while (stack.isNotEmpty() && stack.peek() != "(") {
+                builder.append(stack.pop().reversed())
+            }
+            stack.pop() // Pop (
+            stack.push(builder.toString())
+        } else {
+            stack.push(c.toString())
+        }
+    }  
+    return stack.joinToString("")
+}
+```
+* **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)`
+
+> 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     

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

@@ -17,6 +17,7 @@ Output:
 ```
 
 ## Stack
+We use stack to match the parentheses, and we store the index when any unmatched parentheses are found.
 ```kotlin
 fun minRemoveToMakeValid(s: String): String {
     if (s.isEmpty()) return ""
@@ -51,7 +52,7 @@ fun minRemoveToMakeValid(s: String): String {
 * **Time Complexity**: `O(n)`, to iterate the string for scanning and building the result.
 * **Space Complexity**: `O(n)` for hash set and stack.
 
-Another solution, we can iterate the string from left to right, to remove invalid left parentheses, then iterate from right to left to remove the invalid right parentheses.
+Another solution, we can iterate the string from left to right, to remove umatched left parentheses, then iterate from right to left to remove the unmatched right parentheses.
 
 ```kotlin
 fun minRemoveToMakeValid(s: String): String {
@@ -77,4 +78,47 @@ fun minRemoveToMakeValid(s: String): String {
     }
     return str.toString()
 }
-```
+```
+
+## Greedy
+We can use the similar idea from [921. Minimum Add to Make Parentheses Valid](https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/), we can use a count variable to store the number of umatched left parentheses when iterating from left to right, to remove the unmatched **right** parentheses. Then we iterate from right to left with the count variable to store the number of unmatched right parentheses to remove the unmatched **left** parentheses.
+
+```kotlin
+fun minRemoveToMakeValid(s: String): String {
+    val toRemove = HashSet<Int>()
+    var leftCount = 0
+    for (i in 0 until s.length) {
+        val c = s[i]
+        if (c == '(') leftCount++
+        else if (c == ')') leftCount--
+
+        // More right parentheses that can't match
+        if (leftCount < 0) {
+            toRemove.add(i)
+            leftCount = 0
+        }
+    }
+    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--
+
+        // More left parentheses that can't match
+        if (rightCount < 0) {
+            toRemove.add(i)
+            rightCount = 0
+        }
+    }
+    val str = StringBuilder()
+    for (i in 0 until s.length) {
+        if (toRemove.contains(i)) continue
+        str.append(s[i])
+    }
+    return str.toString()
+}
+```
+
+* **Time Complexity**: `O(n)`, to iterate the string for scanning and building the result.
+* **Space Complexity**: `O(n)` for hash set.

leetcode/1541.minimum-insertions-to-balance-a-parentheses-string.md

@@ -0,0 +1,76 @@
+# [1541. Minimum Insertions to Balance a Parentheses String](https://leetcode.com/problems/minimum-insertions-to-balance-a-parentheses-string/)
+
+## Stack (Greedy or Counting)
+It's a variant of [921. Minimum Add to Make Parentheses Valid](../leetcode/921.minimum-add-to-make-parentheses-valid.md). The difference is that we need to match one left parenthesis with two right parentheses. We can use the similar approach from it:
+1. For left parenthesis, we increase the count.
+2. For right parenthesis, we check if we have two adjacent right parentheses:
+    * There are two right parentheses, we can match one left parenthesis with two right parentheses, we decrease the count.
+    * There is only one right parenthesis, we need to add one right parenthesis, and decrease the count because we can match after adding one right parenthesis.
+3. At the end of iteration, we need to add the right parenthesis for the remaining left parentheses, we add the `count * 2` to the result, we need to add two right parentheses for each left parenthesis.
+
+```kotlin
+fun minInsertions(s: String): Int {
+    var leftCount = 0
+    var insertions = 0
+    var i = 0
+    while (i < s.length) {
+        val c = s[i]
+        if (c == '(') {
+            leftCount++
+        } else {
+            // We check if we have two adjacent right parentheses
+            if (i + 1 < s.length && s[i + 1] == ')') {
+                leftCount-- // We can match one left parenthesis with two right parentheses
+                i++ // We have checked i, and i + 1, so we need to skip i + 1
+            } else { // We only have one right parenthesis
+                insertions++ // We need to add one left parenthesis
+                leftCount-- // We match after adding one left parenthesis
+            }
+        }
+
+        // We check if right parenthesis is more than left parenthesis
+        if (leftCount < 0) {
+            insertions++ // We need to add one left parenthesis
+            leftCount = 0 // We match after adding one left parenthesis
+        }
+        i++
+    }
+    return insertions + leftCount * 2 // We need to add two right parentheses for each left parenthesis
+}
+```
+
+Or we can count the needed right parentheses directly:
+```kotlin
+fun minInsertions(s: String): Int {
+    var rightNeeded = 0 // How many right parentheses we need to match
+    var insertions = 0
+    for (c in s) {
+        if (c == '(') {
+            rightNeeded += 2
+
+            // For the balanced parentheses, we always need the even number of 
+            // right parentheses. For odd number, we have to add one right parenthesis.
+            if (rightNeeded % 2 != 0) {
+                insertions++
+                // Because we add one right parenthesis, so the needed right parentheses - 1
+                rightNeeded-- 
+            }
+        } else {
+            // We have one right parenthesis, so we decrease the needed right parentheses
+            rightNeeded--
+
+            // For negative number of right parentheses, which means left > right
+            // We need to add one left parenthesis to match
+            if (rightNeeded < 0) {
+                insertions++
+                rightNeeded += 2 // After adding one left, we need to add two right parentheses to match.
+            }
+        }
+    }
+    return insertions + rightNeeded
+}
+```
+
+## References
+* https://www.youtube.com/watch?v=MipkQzEkhBM
+* The second approach: https://leetcode.cn/problems/minimum-insertions-to-balance-a-parentheses-string/solutions/391236/ping-heng-gua-hao-zi-fu-chuan-de-zui-shao-cha-ru-2/comments/1558355

leetcode/1614.maximum-nesting-depth-of-the-parentheses.md

@@ -0,0 +1,23 @@
+# [1614. Maximum Nesting Depth of the Parentheses](https://leetcode.com/problems/maximum-nesting-depth-of-the-parentheses/description/)
+
+## Stack
+We can use stack to trace the depth of the parentheses. When we meet a `(`, we push it into the stack. When we meet a `)`, we pop the stack and update the maximum depth. To optimizee the space complexity, we can use a variable to store the count of unmatched left parentheses and update the maximum depth.
+
+```kotlin
+fun maxDepth(s: String): Int {
+    var maxDepth = 0
+    var leftCount = 0
+    for (c in s) {
+        if (c == '(') {
+            leftCount++
+            maxDepth = maxOf(maxDepth, depth)
+        } else if (c == ')') {
+            leftCount--
+        }
+    }
+    return maxDepth
+}
+```
+
+* **Time Complexity:** `O(n)`.
+* **Space Complexity:** `O(1)`.