Reorganize the note of dynamic programming; fix some typos

Author: enginebai

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

@@ -8,11 +8,8 @@ fun maxProfit(prices: IntArray): Int {
     var lowestPrice = prices[0]
     var maxProfit = 0
     for (i in 1 until prices.size) {
-        if (prices[i] < lowestPrice) {
-            lowestPrice = prices[i]
-        } else {
-            maxProfit = max(maxProfit, prices[i] - lowestPrice)
-        }
+        lowestPrice = min(lowestPrice, prices[i])
+        maxProfit = max(maxProfit, prices[i] - lowestPrice)
     }
     return maxProfit
 }

leetcode/198.house-robber.md

@@ -63,7 +63,6 @@ fun rob(nums: IntArray): Int {
     if (nums.size == 1) return nums[0]
     if (nums.size == 2) return max(nums[0], nums[1])
 
-    val dp = IntArray(nums.size)
     var p2 = nums[0]
     var p1 = max(nums[0], nums[1])
     for (i in 2 until nums.size) {

leetcode/509.fibonacci-number.md

@@ -19,6 +19,23 @@ fun fib(n: Int): Int {
     }
 }
 ```
+
+```python
+def fib(self, n: int) -> int:
+    memo = {}
+    def helper(k: int) -> int:
+        if k <= 1:
+            return k
+        
+        if k in memo:
+            return memo[k]
+        
+        memo[k] = helper(k - 1) + helper(k - 2)
+        return memo[k]
+    
+    return helper(n)
+```
+
 * **Time Complexity**: `O(n)`.
 * **Space Complexity**: `O(n)`.
 
@@ -35,6 +52,17 @@ fun fib(n: Int): Int {
     return dp[n]
 }
 ```
+
+```python
+ def fib(self, n: int) -> int:
+    if n <= 1: 
+        return n
+    dp = [0, 1] + [0] * (n - 1)
+    for i in range(2, n + 1):
+        dp[i] = dp[i - 1] + dp[i - 2]
+    return dp[n]
+```
+
 * **Time Complexity**: `O(n)`.
 * **Space Complexity**: `O(n)`.
 
@@ -53,5 +81,18 @@ fun fib(n: Int): Int {
     return fib
 }
 ```
+
+```python
+def fib(self, n: int) -> int:
+    if n <= 1: 
+        return n
+    n1, n2 = 1, 0
+    result = 0
+    for i in range(2, n + 1):
+        result = n1 + n2
+        n2 = n1
+        n1 = result
+    return result
+```
 * **Time Complexity**: `O(n)`.
 * **Space Complexity**: `O(1)`.

leetcode/746.min-cost-climbing-stairs.md

@@ -1,13 +1,35 @@
 ## [746. Min Cost Climbing Stairs](https://leetcode.com/problems/min-cost-climbing-stairs/)
 
-The `dp[i]` represents the cost **to** i-th step:
-* To 0-th step and 1-th step cost 0.
-* The cost to i-th step will be the minimum of to (i - 1)-th cost + (i - 1) cost or to (i - 2)-th cost + (i - 2) cost.
+We start either from index `0` or `1`, and find the min cost when reaching `n-th` step. There are two way to represent the states:
+
+```js
+# to(i) = min(to(i - 1) + cost[i - 1], to(i - 2) + cost[i - 2])
+# from(i) = cost[i] + min(from(i - 1), from(i - 2))
+```
+
+### `To` State
+
+The `to(i)` / `dp[i]` represents the cost **to** i-th step:
+* To `0` or `1` step cost 0, because we start from index `0` or `1`.
+* The cost to `i-th` step will be the minimum of `to(i - 1) + cost[i - 1]` and `to(i - 2) + cost[i - 2]`.
 
 ```kotlin
+// Recursive with memoization
+private val memo = hashMapOf<Int, Int>()
+
 fun minCostClimbingStairs(cost: IntArray): Int {
-    if (cost.size == 2) return min(cost[0], cost[1])
+    return to(cost, cost.size)
+}
+
+private fun to(cost: IntArray, i: Int): Int {
+    if (i == 0 || i == 1) return 0
+    if (memo.containsKey(i)) return memo[i]!!
+    memo[i] = min(to(cost, i - 1) + cost[i - 1], to(cost, i - 2) + cost[i - 2])
+    return memo[i]!!
+}
 
+// Bottom-Up DP
+fun minCostClimbingStairs(cost: IntArray): Int {
     val n = cost.size
     val dp = IntArray(n + 1)
     dp[0] = 0
@@ -19,26 +41,27 @@ fun minCostClimbingStairs(cost: IntArray): Int {
 }
 ```
 
-Or we can represent `dp[i]` to be the cost that we pay in order to climb **from** i-th step. That is, to climbing from i-th step, we have to pay `dp[i] = cost[i] + min(dp[i - 1], dp[i - 2])`.
+### `From` State
+Or we can represent `dp[i]` to be the cost that we pay in order to climb **from** `i-th` step. We have to pay `dp[i] = cost[i] + min(dp[i - 1], dp[i - 2])`.
 
 ```kotlin
+// Time Complexity: O(n)
+// Space Complexity: O(n)
 fun minCostClimbingStairs(cost: IntArray): Int {
     val n = cost.size
     val dp = IntArray(n + 1)
     dp[0] = cost[0]
     dp[1] = cost[1]
-    for (i in 2..n) {
+    for (i in 2 until n) {
         dp[i] = cost[i] + min(dp[i - 1], dp[i - 2])
     }
+    // To n-th step, we can either start from n - 1 or n - 2.
     return min(dp[i - 1], dp[i - 2])
 }
-```
 
-* **Time Complexity**: `O(n)` for one for-loop.
-* **Space Complexity**: `O(n)` for `dp` array.
-
-### Bottom-DP (Space Optimization)
-```kotlin
+// Space Optimization
+// Time Complexity: O(n)
+// Space Complexity: O(1)
 fun minCostClimbingStairs(cost: IntArray): Int {
     if (cost.size == 2) return min(cost[0], cost[1])
 
@@ -54,5 +77,23 @@ fun minCostClimbingStairs(cost: IntArray): Int {
 }
 ```
 
-* **Time Complexity**: `O(n)` for one for-loop.
-* **Space Complexity**: `O(1)`.
+```python
+def minCostClimbingStairs(self, cost: List[int]) -> int:
+    n = len(cost)
+    # dp[i] = the cost from i-th step
+    dp = [cost[0], cost[1]] + [0] * (n - 2)
+    for i in range(2, n):
+        dp[i] = cost[i] + min(dp[i - 1], dp[i - 2])
+    return min(dp[n - 1], dp[n - 2])
+
+# Space Optimization
+def minCostClimbingStairs(self, cost: List[int]) -> int:
+    n = len(cost)
+    # dp[i] = the cost from i-th step
+    n1, n2 = cost[0], cost[1]
+    for i in range(2, n):
+        result = cost[i] + min(n1, n2)
+        n1 = n2
+        n2 = result
+    return min(n1, n2)
+```

media/assembly-line-scheduling.png

@@ -78,14 +78,14 @@ fun insertSort(A) {                     // ---- Times ----
 This worst running time can expressed as `a*n^2 + b*n + c`, it's a **quadratic function** of `n`.
 
 We shall usually conccentrate on the worst-case running time, because of the three reasons:
-1. It's the upper bound of running time for any input, it gives us a guarantee that the algorithm will never tak any longer.
+1. It's the upper bound of running time for any input, it gives us a guarantee that the algorithm will never take any longer.
 2. For some algorithm, the worst case occurs fairly often.
 3. The "average case" is often roughly as bad as the worst case.
 
 We expect that the same algorithm running on a fast machine will run faster than the same algorithm on a slow one, however, we'd like to be able to compare without worrying about how fast the machine is, so we compare the running time based on *asymptotic performance* (the abstraction way) relative to the input size.
 
 ## Asymptotic Notation
-When look at input sizes large engough to make only the order of growth of the running time relevant, we use *asymptotic notation* to express the **rate of growth** of an algorithm's running time in terms of the input size `n`.
+When we look at input sizes large engough to make only the order of growth of the running time relevant, we use *asymptotic notation* to express the **rate of growth** of an algorithm's running time in terms of the input size `n`.
 
 For the worst-case running time of *insert sort* is `a*n^2 + b*n + c`, what we care about is the **order of growth**, we therefore consider: