Problems/dp (#25)

* Update linked list solutions

* Add 509. Fibonacci Number solution

* Update dynamic programming notes

* Update dp and stack note

* Add stack & queue problem solutions list

* Update dp note

* Add 70. Climbing Stairs solution

* Add 746. Min Cost Climbing Stairs solution

* Update 746. Min Cost Climbing Stairs solution note

* Add 62. Unique Paths solution

* Add 62. Unique Paths DFS solution

* Update 20. Valid Parentheses solution

* Update the solutions to some stack problem

* Add 63. Unique Paths II solution

* Add 96. Unique Binary Search Trees solution

* Update 1249. Minimum Remove to Make Valid Parentheses solution

* Update stack solutions

* Add dynamic programming solution to 121. Best Time to Buy and Sell Stock

* Update 394. Decode String solution

* Update 121. Best Time to Buy and Sell Stock dp note

* Add 122. Best Time to Buy and Sell Stock II dp solution

* Update dp note for Best Time to Buy and Sell Stock series problems

* Update knapsack problems note

* Add 416. Partition Equal Subset Sum solution

* Add 494. Target Sum solution

* Add unbounded knapsack problem note

* Add 322. Coin Change different kinds of solutions

* Fix the 0/1 knapsack problem implementation

* Add 518. Coin Change 2 solution

* Add 198. House Robber solution

* Add 213. House Robber II solution

* Add 337. House Robber III solutions

* Add longest common subsequence note to dp

* Add 300. Longest Increasing Subsequence solution

* Update tree problem solutions

* Add 516. Longest Palindromic Subsequence solution

* Update 300. Longest Increasing Subsequence solution

* Add 674. Longest Continuous Increasing Subsequence solution

* Add 718. Maximum Length of Repeated Subarray solution

* Add 5. Longest Palindromic Substring dp solution

* Update 516. Longest Palindromic Subsequence solution

* Update 101. Symmetric Tree solution

* Update 53. Maximum Subarray solution

* Add 152. Maximum Product Subarray solution

* Add 55. Jump Game solution

* Update 55. Jump Game solution

* Add 139. Word Break solution

* Add 64. Minimum Path Sum solution

* Add 279. Perfect Squares solution

* Add 647. Palindromic Substrings solutiong

* Update 543. Daimeter of Binary Tree solution

* Add 264. Ugly Number II solutions

* Fix typos in greedy note, update dp problem list

* Update DP note for knapsack problem of all implementation and solution for space optimization

Author: enginebai

leetcode/101.symmetric-tree.md

@@ -15,30 +15,26 @@ fun check(left: TreeNode?, right: TreeNode?): Boolean {
 
 ### Iterative
 ```kotlin
+val emptyNode = TreeNode(-1)
 fun isSymmetric(root: TreeNode?): Boolean {
     if (root == null) return true
-    else {
-        val queue = ArrayDeque<TreeNode>()
-        if (root?.left != null) queue.add(root?.left)
-        if (root?.right != null) queue.add(root?.right)
+    val queue = ArrayDeque<TreeNode>()
+    if (root.left != null) queue.addLast(root.left)
+    if (root.right != null) queue.addLast(root.right)
+    while (queue.isNotEmpty()) {
+        val left = queue.removeFirst()
+        if (queue.isEmpty()) return false
+        val right = queue.removeFirst()
 
-        while (!queue.isEmpty()) {
-            val left = queue.removeFirstOrNull()
-            val right = queue.removeFirstOrNull()
-            
-            if (left == null && right == null) continue
-            if (left == null || right == null || left?.`val` != right?.`val`) return false
-            
-            // We have to push in the symmetric order
-            queue.addLast(left!!.left)
-            queue.addLast(right!!.right)
+        if (left == emptyNode && right == emptyNode) continue
+        if (left == emptyNode || right == emptyNode || left.`val` != right.`val`) return false
 
-            queue.addLast(left!!.right)
-            queue.addLast(right!!.left)
-        }
-        return true
+        // Make sure to enqueue empty node
+        if (left.left != null) queue.addLast(left.left!!) else queue.addLast(emptyNode)
+        if (right.right != null) queue.addLast(right.right!!) else queue.addLast(emptyNode)
+        if (left.right != null) queue.addLast(left.right!!) else queue.addLast(emptyNode)
+        if (right.left != null) queue.addLast(right.left!!) else queue.addLast(emptyNode)
     }
+    return true
 }
-```
-
-> Idea is correct, but code won't compile successfully, LeetCode jvm doesn't support `removeFirstOrNull()` function.
+```

leetcode/104.maximum-depth-of-binary-tree.md

@@ -11,4 +11,24 @@ private fun max(n1: Int, n2: Int) = if (n1 > n2) n1 else n2
 ```
 
 * **Time Complexity**: `O(n)`, iterate all nodes.
-* **Space Complextiy**: `O(height)`, height might be `lg n` (balanced) or `n` (skewed)
+* **Space Complextiy**: `O(height)`, height might be `lg n` (balanced) or `n` (skewed)
+
+### BFS
+```kotlin
+fun maxDepth(root: TreeNode?): Int {
+    if (root == null) return 0
+    val queue = ArrayDeque<TreeNode>()
+    var depth = 0
+    queue.addLast(root)
+    while (queue.isNotEmpty()) {
+        val size = queue.size
+        for (i in 0 until size) {
+            val node = queue.removeFirst()
+            if (node.left != null) queue.addLast(node.left!!)
+            if (node.right != null) queue.addLast(node.right!!)
+        }
+        depth++
+    }
+    return depth
+}
+```

leetcode/121.best-time-to-buy-and-sell-stock.md

@@ -1,9 +1,7 @@
 ## [121. Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/)
 
-### Straightforward
-Strategies:
-1. Look for the lowest buy price: Check current price, if current price < buy price, then update buy price to current one.
-2. Look for max profit: If we can sell, then check if the current profit > max profit.
+### Greedy
+We're going to find minimium price to buy and calculate max profit for every day.
 
 |           | Init | 7 | 1 | 5 | 3 | 6 | 4 |
 |-----------|------|---|---|---|---|---|---|
@@ -12,25 +10,46 @@ Strategies:
 
 ```kotlin
 fun maxProfit(prices: IntArray): Int {
-    var maxProfit = 0
-    var minPrice = Int.MAX_VALUE
+    var min: Int? = null
+    var profit = 0
     for (i in 0 until prices.size) {
-        if (minPrice > prices[i]) {
-            minPrice = prices[i]
-        }
-
-        val currentProfit = prices[i] - minPrice
-        if (currentProfit > maxProfit) {
-            maxProfit = currentProfit
+        if (min == null) {
+            min = prices[i]
+        } else {
+            if (prices[i] < min) min = prices[i]
+            val currentProfit = prices[i] - min
+            profit = if (currentProfit > profit) currentProfit else profit
         }
     }
-    return maxProfit
+    return profit
 }
 ```
 
 * **Time Complexity**: `O(n)`.
 * **Space Complexity**: `O(1)`.
 
+### Dynamic Programming
+We can apply the framework mentioned on [Dynamic Programming - Best Time to Buy and Sell Stock Problems](../topics/dynamic-programming.md#best-time-to-buy-and-sell-stock-problems), where `k` is 1, so the profit is always 0 when we're going to buy the stock.
+
+```kotlin
+fun maxProfit(prices: IntArray): Int {
+    val n = prices.size
+    val dp = Array(prices.size) { _ -> IntArray(2) }
+    // The max profit for Cash state is 0
+    dp[0][0] = 0
+    // The max profit for Stock state is the amount we pay for the stock
+    dp[0][1] = -prices[0]
+    for (i in 1 until prices.size) {
+        dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i])
+
+        // It should be max(dp[i - 1][1], dp[i - 1][0] - prices[i])
+        // We can only buy once, so the dp[i - 1][0] is always 0 (always buy stock at i-th price)
+        dp[i][1] = max(dp[i - 1][1], 0 - prices[i])
+    }
+    return dp[n - 1][0]
+}
+```
+
 ### Brute Force
 ```kotlin
 fun maxProfit(prices: IntArray): Int {

leetcode/122.best-time-to-buy-and-sell-stock-ii.md

@@ -1,46 +1,45 @@
 ## [122. Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/)
 
-We're going to find all the range of that prices go up. (The gree line below)
+### Greedy
+We're going to find all the range of that prices go up. (The green line below)
 
 ![Prices Chart](../media/122.best-time-to-buy-and-sell-stock-ii.png)
 
+We can break the profit by day, if the price of today is greater than previous day, then there will be some profit on that day.
+
 ```kotlin
 fun maxProfit(prices: IntArray): Int {
-    var totalProfit = 0
-    var buyPrice: Int? = null
-
-    var day = 0
-    while (day < prices.size) {
-        // Check to buy: I didn't buy before and the price is lower
-        if (buyPrice == null && (day + 1 < prices.size && prices[day] < prices[day + 1])) {
-            buyPrice = prices[day]
-        }
-
-        // Check to sell: (price starts to fall down, or it's the last trade day) and I bought before
-        if (buyPrice != null && (day + 1 == prices.size || (day + 1 < prices.size && prices[day + 1] < prices[day]))) {
-            val profit = prices[day] - buyPrice
-            if (profit > 0) {
-                totalProfit += profit
-                buyPrice = null
-            }
+    var profit = 0
+    for (i in 1 until prices.size) {
+        if (prices[i] > prices[i - 1]) {
+            profit += prices[i] - prices[i - 1]
         }
-
-        day++
     }
-    return totalProfit
-}  
+    return profit
+}
 ```
 
-> More simple way to implement.
+### Dynamic Programming
+We can apply the framework mentioned on [Dynamic Programming - Best Time to Buy and Sell Stock Problems](../topics/dynamic-programming.md#best-time-to-buy-and-sell-stock-problems), where `k` is positive infinite. (So we can simply ignore it)
 
 ```kotlin
 fun maxProfit(prices: IntArray): Int {
-    var profit = 0
+    val dp = Array(prices.size) { _ -> IntArray(2) }
+    dp[0][0] = 0
+    dp[0][1] = -prices[0]
     for (i in 1 until prices.size) {
-        if (prices[i] > prices[i - 1]) {
-            profit += prices[i] - prices[i - 1]
-        }
+        dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i])
+        // We can buy/sell more times, so we will have previous cash profit dp[i - 1][0], not 0, this is the difference of problem 121.
+        dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i])
     }
-    return profit
+    return dp[prices.size - 1][0]
 }
+```
+
+```js
+Day i       1	2	3	4	5	6	
+Price i     7	1	5	3	6	4	
+----------------------------------
+dp[i][0]    0	0	4	4	7	7	
+dp[i][1]    -7	-1	-1	1	1	3
 ```

leetcode/123.best-time-to-buy-and-sell-stock-iii.md

@@ -0,0 +1,23 @@
+## [123. Best Time to Buy and Sell Stock III](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/)
+
+The k times transaction limit
+
+```kotlin
+fun maxProfit(prices: IntArray): Int {
+    val maxK = 2
+    val dp = Array(prices.size) { _ -> Array(2) { _ -> IntArray(maxK + 1) }}
+    for (i in 0 until prices.size) {
+        for (k in 1..maxK) {
+            if (i == 0) {
+                dp[i][0][k] = 0
+                dp[i][1][k] = -prices[0]
+                continue
+            }
+            dp[i][0][k] = max(dp[i - 1][0][k], dp[i - 1][1][k] + prices[i])
+            // The max times transactions on (i - 1)-th day should be k - 1, so that we can buy on i-th day
+            dp[i][1][k] = max(dp[i - 1][1][k], dp[i - 1][0][k - 1] - prices[i])
+        }
+    }
+    return dp[prices.size - 1][0][maxK]
+}
+```

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

@@ -2,29 +2,38 @@
 
 ```kotlin
 fun minRemoveToMakeValid(s: String): String {
-    // The index of invalid right parenthese to be removed at first
-    val toRmoveIndexList = mutableListOf<Int>()
-    val leftParentheseStack = Stack<Int>()
+    if (s.isEmpty()) return ""
+    val toRemoveIndexes = hashSetOf<Int>()
+    // left parentheses index
+    val stack = Stack<Int>()
+    // Scan the string to find invalid right parentheses
     for (i in 0 until s.length) {
-        if (s[i] == '(') {
-            leftParentheseStack.push(i)
-        } else if (s[i] == ')') {
-            // The right parenthes can't be matched
-            if (leftParentheseStack.isEmpty()) {
-                toRmoveIndexList.add(i)
+        val c = s[i] 
+        if (c == '(') {
+            stack.push(i)
+        } else if (c == ')') {
+            if (stack.isEmpty()) { 
+                toRemoveIndexes.add(i)
             } else {
-                leftParentheseStack.pop()
+                stack.pop()
             }
         }
+    } 
+    // Invalid left parentheses
+    while (!stack.isEmpty()) {
+        toRemoveIndexes.add(stack.pop())
     }
-    while (!leftParentheseStack.isEmpty()) {
-        toRmoveIndexList.add(leftParentheseStack.pop())
-    }
-    val result = StringBuilder()
+    
+    val answer = StringBuilder()
     for (i in 0 until s.length) {
-        if (toRmoveIndexList.contains(i)) continue
-        else result.append(s[i])
+        if (toRemoveIndexes.contains(i)) continue
+        else answer.append(s[i])
     }
-    return result.toString()
+    return answer.toString()
 }
-```
+```
+
+* **Time Complexity**: `O(n)`, to iterate the string for scanning and building the result.
+* **Space Complexity**: `O(n)` for hash table and stack.
+
+> Another solution, we can iterate the string from left to right, to remove invalid right parentheses, then iterate from right to left to remove the invalid left parentheses.

leetcode/139.word-break.md

@@ -0,0 +1,74 @@
+## [139. Word Break](https://leetcode.com/problems/word-break/)
+
+Let's define `dp[i]` as the state if we can build the substring `s[0:i]` from diectionary. And the state transition will be
+
+```js
+// The state of s[0:i]
+dp[i] = 
+    dp[j]       // The state of s[0:j], 
+    && s[j:i]   // The remaining substring, check if it in the dictionary
+```
+
+For example, `"cars"` and `["car", "ca", "rs"]`:
+
+We will iterate `i` from 0 to `len` for find if we can build substring `s[0:i]`:
+
+```js
+i  j  c a r s
+1, 0, c        // dp[0] && dict.contains("c") = false
+2, 0, c a      // dp[0] && dict.contains("ca") = true
+2, 1,   a
+3, 0, c a r
+3, 1,   a r
+3, 2,     r
+4, 0, c a r s
+4, 1,   a r s
+4, 2,     r s
+4, 3,       s
+```
+
+```kotlin
+fun wordBreak(s: String, wordDict: List<String>): Boolean {
+    val wordDictSet = HashSet(wordDict)
+    val dp = BooleanArray(s.length + 1)
+
+    // Base case: it's always true for empty string case
+    dp[0] = true
+
+    // Iterate every states
+    for (i in 1..s.length) {
+        for (j in 0 until i) {
+            val substring = s.substring(j, i)
+            // The state of s[0:j] and the state of s[j:i]
+            if (dp[j] && wordDictSet.contains(substring)) {
+                dp[i] = true
+                break
+            }
+        }
+    }
+    return dp[s.length]
+}
+```
+
+* **Time Complexity**: `O(n^2)` where `n` is the length of string.
+* **Space Complexity**: `O(n)` for dp table.
+
+Here we don't iterate to build substring start from `i`, because the `dp[i]` represent the state of `s[0:i]`.
+
+```js
+c a r s
+-------
+c
+c a
+c a r
+c a r s
+  a
+  a r
+  a r s
+    r
+    r s
+      s
+```
+
+### My First Attempt (WA)
+To iterate all words in diectionary, and replace in the `s`, then check the remaining substring in diectionary recursively. It failed at the case `s = "cars"`, dictionary = `["car", "ca", "rs"]`.