Update notes of dynamic programming problems

Author: enginebai

Algorithms.code-workspace

@@ -0,0 +1,12 @@
+{
+	"folders": [
+		{
+			"path": "."
+		},
+		{
+			"name": ".leetcode",
+			"path": "../../../.leetcode"
+		}
+	],
+	"settings": {}
+}

leetcode/1337.the-k-weakest-rows-in-a-matrix.md

@@ -40,7 +40,7 @@ fun kWeakestRows(mat: Array<IntArray>, k: Int): IntArray {
 * **Space Complexity**: `O(m)`.
 
 ## Optimal Heap + Binary Search
-The 1s are always before 0s, so each row is sorted, and we can apply binary search to find the last `1` for counting.
+The `1s` are always before `0s`, so each row is sorted, and we can apply binary search to find the last `1` for counting (or the first `0`).
 
 ```kotlin
 fun kWeakestRows(mat: Array<IntArray>, k: Int): IntArray {

leetcode/1351.count-negative-numbers-in-a-sorted-matrix.md

@@ -0,0 +1,99 @@
+# [1351. Count Negative Numbers in a Sorted Matrix](https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/description/)
+
+## Brute Force
+We can count the negative numbers in the matrix by iterating each element.
+
+```python
+def countNegatives(self, grid: List[List[int]]) -> int:
+    m, n = len(grid), len(grid[0])
+    count = 0
+    for i in range(m):
+        for j in range(n):
+            if grid[i][j] < 0:
+                count += 1
+    return count
+```
+* **Time Complexity**: `O(m * n)`.
+* **Space Complexity**: `O(1)`.
+
+## Count in Z-shape
+Since each row (column) is sorted, we can count the negative numbers in a Z-shape.
+
+```
+++++++
+++++--
+++++--
++++---
++-----
++-----
+```
+
+![](../media/240.search-a-2d-matrix-ii.png)
+
+We start from left-botton corner, and move up to right-top corner, and count the negative numbers in each column.
+
+```python
+def countNegatives(self, grid: List[List[int]]) -> int:
+    m = len(grid)
+    n = len(grid[0])
+
+    r = m - 1
+    c = 0
+    count = 0
+    while c < n:
+        while 0 <= r and grid[r][c] < 0:
+            r -= 1
+        count += m - r - 1
+        c += 1
+        
+    return count
+
+## Equivalently, starting from right-top corner, and move down to left-bottom corner.
+def countNegatives(self, grid: List[List[int]]) -> int:
+    count = 0
+    n = len(grid[0])
+    negIndex = n - 1
+
+    for r in grid:
+        while negIndex >= 0 and r[negIndex] < 0:
+            negIndex -= 1
+        
+        count += (n - negIndex - 1)
+    
+    return count
+```
+
+* **Time Complexity**: `O(m + n)`.
+* **Space Complexity**: `O(1)`.
+
+## Binary Search in Each Row (Column)
+For each row (column), we can use binary search to find the first negative number, and the count of negative numbers will be `n - index`.
+
+```kotlin
+fun countNegatives(grid: Array<IntArray>): Int {
+    var count = 0
+    for (i in 0 until grid.size) {
+        val index = binarySearch(grid[i])
+        println(index)
+        count += grid[i].size - index
+    }
+    return count
+}
+
+private fun binarySearch(array: IntArray): Int {
+    var left = 0
+    var right = array.size - 1
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+        if (0 <= array[middle]) {
+            left = middle + 1
+        } else {
+            right = middle - 1
+        }
+    }
+    return left
+}
+```
+
+* **Time Complexity**: `O(m * lg(n))`.
+* **Space Complexity**: `O(1)`.

leetcode/139.word-break.md

@@ -1,39 +1,53 @@
-## [139. Word Break](https://leetcode.com/problems/word-break/)
+# [139. Word Break](https://leetcode.com/problems/word-break/)
+
+## Observation
+```js
+// For word "cars" and dictionary ["car", "ca", "rs"]
+f(car) =
+    f(ca) + "r" in dict ||
+    f(ca) =
+        f(c) + "a" in dict ||
+        f() + "ca" in dict
+    f(c) + "ar" in dict ||
+    f(c) = 
+        f() + "c" in dict
+    f() + "car" in dict
+```
 
-### Observation
 1. **Optimal substructure**: We can break down the string into smaller substrings, and we can build the substrings from dictionary to build the solution for entire string.
-2. **Overlapping subproblems**: When breaking down the string, we might have same substrings, and we can reuse the solution.
+2. **Overlapping subproblems**: When breaking down the string, we might have same substrings (`f(c)` from above example), and we can reuse the solution.
 3. **Memoization**: We keep track of whether substrings can be built from dictionary.
 
 Suppose we break down the string into `s[0:i]` and `s[i:]`, if we can build `s[0:i]` from dictionary recursively and `s[i:]` exists in dictionary, then we can build `s[0:i] + s[i:]` from dictionary. Then we break down `s[0:i]` into `s[0:j]` and `s[j:i]`, and if we can build `s[0:j]` from dictionary recursively and `s[j:i]` exists in dictionary, then we can build `s[0:j] + s[j:i]` from dictionary. And so on. Therefore, we can solve this problem by dynamic programming.
 
 ```js
 // f(s) = word break function of input string s.
-f(s) = f(s[0:i]) && f(s[i:])
-     = f(s[0:i]) && if s[i:] in dict
+f(s) = f(s[0:i]) && if s[i:] in dict for i in 1 to s.length
+
+// Break into smaller substrings
+f(s[0:i]) = f(s[0:j]) && if s[j:i] in dict for j in 1 to i
 
-f(s[0:i]) = f(s[0:j]) && f(s[j:i])
-          = f(s[0:j]) && if s[j:i] in dict
+f(s[0:j]) = f(s[0:k]) && if s[k:j] in dict for k in 1 to j
 
-... so on.
+// ... so on.
 ```
 
 Here we don't know the `i` and `j` for breaking down the string, so we will try all possible `i` and `j` (iterate all substrings) to find if we can build the string from dictionary.
 
-```js
+For example
+```kotlin
 f('leetcode') =
-    (f('leetcod') && 'e' in dict) &&
-    (f('leetco') && 'de' in dict) &&
-    (f('leetc') && 'ode' in dict) &&
-    (f('leet') && 'code' in dict) &&
-    (f('lee') && 'tcode' in dict) &&
-    (f('le') && 'etcode' in dict) &&
-    (f('l') && 'eetcode' in dict) &&
+    (f('leetcod') && 'e' in dict) ||
+    (f('leetco') && 'de' in dict) ||
+    (f('leetc') && 'ode' in dict) ||
+    (f('leet') && 'code' in dict) ||
+    (f('lee') && 'tcode' in dict) ||
+    (f('le') && 'etcode' in dict) ||
+    (f('l') && 'eetcode' in dict) ||
     (f('') && 'leetcode' in dict)
 ```
 
-### Top-Down DP
-
+## Top-Down DP
 ```kotlin
 fun wordBreak(s: String, wordDict: List<String>): Boolean {
     val memo = hashMapOf<String, Boolean>()
@@ -60,9 +74,10 @@ private fun breakdown(s: String, dict: HashSet<String>, memo: HashMap<String, Bo
 * **Space Complexity**: `O(n)` for memoization.
 
 ## Bottom-Up DP
-Let's define `dp[i]` as the state if we can build the substring `s[0:i]` from dictionary, and the state transition will be
+Let's define `dp[i]` as the state if we can build the substring `s[0:i]` from dictionary, and the state transition will be:
 
 ```js
+// s = 0.....j.....i
 // The state of s[0:i] = s[0:j] + s[j:i]
 dp[i] = 
     dp[j]       // The state of s[0:j], 
@@ -110,6 +125,7 @@ fun wordBreak(s: String, wordDict: List<String>): Boolean {
 }
 ```
 
+## Dry Run
 ```js
 println(wordBreak("cars", listOf("car", "rs", "ca")))
 0, 1, c

leetcode/264.ugly-number-ii.md

@@ -1,10 +1,11 @@
-## [264. Ugly Number II](https://leetcode.com/problems/ugly-number-ii/)
+# [264. Ugly Number II](https://leetcode.com/problems/ugly-number-ii/)
 
-What's the next number? It would be the smallest number **all the previously existing numbers multiplied by 2 or 3, 5** that does't not shown before.
+## Dynamic Programming
+What's the next number? It would be the smallest number **all the previously existing ugly numbers multiplied by 2 or 3, 5** that hasn't shown before.
 
-We assume there is one number shown, which is `1`, the next number is `min(2 * 1, 3 * 1, 5 * 1) && not shown before`, that is 2, and you can think that comes from `min(2 * dp[1], 3 * dp[1], 5 * dp[1])`.
+We start calculating from `1`, the next number is `min(2 * 1, 3 * 1, 5 * 1)` that hasn't shown, that is 2, and you can think that is `dp[n = 2]` which comes from `min(2 * dp[n = 1], 3 * dp[1], 5 * dp[1])`.
 
-Again, what's the next number? Now we only need to consider `min(2 * 2, 3 * 1, 5 * 1)`, that would be `min(2 * dp[2], 3 * dp[1], 5 * dp[1])`, that means we have three pointers (for 2, 3, 5 respectively) points to the previous existing number, then we move the pointer if we use that in the round.
+Then, what's the next number? Now we only need to consider `min(2 * 2, 3 * 1, 5 * 1)`, that would be `min(2 * dp[2], 3 * dp[1], 5 * dp[1])`, that means we have three pointers (for 2, 3, 5 respectively) points to the previous existing number, then we move the pointer if we use that in the round.
 
 ```js
 n=1, dp[1] = 1 // base case
@@ -20,6 +21,23 @@ n=4, dp[4] = min(dp[2] * 2, dp[2] * 3, dp[1] * 5)
 // pointer          3          2          1
 ```
 
+The wrong way to think this problem is that we just maintain the three pointers and move them to the next when selecting it, and we can get the result. But the correct way is that we need to consider the next number **from the previous existing numbers**, and we need to maintain the three pointers to point to the previous existing number.
+
+```js
+n=1, 1
+n=2, min(2 * 1, 3 * 1, 5 * 1) = 2
+n=3, min(2 * 2, 3 * 1, 5 * 1) = 3
+n=4, min(2 * 2, 3 * 2, 5 * 1) = 4
+n=5, min(2 * 3, 3 * 2, 5 * 1) = 5
+n=6, min(2 * 3, 3 * 2, 5 * 2) = 6
+        // Which one to select?
+n=7, min(2 * 4, 3 * 2, 5 * 2) = 6 // select 2 * 3, wrong answer
+         ^^^^^
+
+n=7, min(2 * 3, 3 * 3, 5 * 2) = 9 // select 3 * 2, wrong answer
+                ^^^^^
+```
+
 ```kotlin
 fun nthUglyNumber(n: Int): Int {
     if (n == 1) return n

leetcode/279.perfect-squares.md

@@ -1,5 +1,32 @@
 ## [279. Perfect Squares](https://leetcode.com/problems/perfect-squares/)
 
+```js
+f(12) = min( 
+    9 + f(3)
+    4 + f(8)
+    1 + f(11)
+)
+
+f(3) = min(
+    1 + f(2)
+)
+
+f(8) = min(
+    4 + f(4)
+    1 + f(7)
+)
+
+f(11) = min(
+    9 + f(2)
+    4 + f(7)
+    1 + f(10)
+)
+
+// So on...
+```
+
+We can break down the problem into subproblems: `f(n)` = `min(f(n - i*i) + 1)` where `n - i*i >= 0` and `i` starts from 1.
+
 Suppose `dp[i]` represents the minimum perfect squares number to construct `i`.
 
 ```js

leetcode/300.longest-increasing-subsequence.md

@@ -83,8 +83,14 @@ fun lengthOfLIS(nums: IntArray): Int {
 ### Time Optimization with Binary Search
 We maintain a list for LIS, and iterate every item in the array:
 1. If the item is greater than the last item of LIS, we append it to the LIS. This forms a longer LIS.
-2. Otherwise, we find the first item in LIS that is greater than or equal to the current item, and replace it with the current item. This keeps the list sorted, and the LIS is still valid.
+2. Otherwise, we find the first item in LIS that is greater than or equal to the current item, and replace it with the current item. This keeps the list sorted, and the LIS is still valid. The LIS becomes smaller to form a possible longer LIS.
 
+```js
+current = 3
+LIS = [1, 2, 7, 8]
+```
+
+Then we find the first item in LIS that is greater than or equal to `3`, which is `7`. We replace `7` with `3`, and the LIS becomes `[1, 2, 3, 8]`.
 At last, the list size is the LIS.
 
 ```kotlin