Update some notes of different problems

Author: enginebai

README.md

@@ -7,18 +7,18 @@ This project offers a curated collection of notes and resources covering fundame
 - [Introduction](./topics/introduction.md)
 - [Complexity](./topics/complexity.md)
 - [Array & String](./topics/array.md)
-- [Hash Table](./topics/hash-table.md)
 - [Sorting](./topics/sorting.md)
+- [Hash Table](./topics/hash-table.md)
 - [Binary Search](./topics/binary-search.md)
 - [Linked List](./topics/linked-list.md)
 - [Stack & Queue](./topics/stack-queue.md)
 - [Tree](./topics/tree.md)
 - [Heap & Priority Queue](./topics/heap.md)
 - [Graph](./topics/graph.md)
-- [Shortest Path](./topics/shortest-path.md)
 - [Recursion](./topics/recursion.md)
 - [Dynamic Programming](./topics/dynamic-programming.md)
 - [Greedy](./topics/greedy.md)
+- [Shortest Path](./topics/shortest-path.md)
 - [Backtracking](./topics/backtracking.md)
 
 ## Problems & Solutions

leetcode/1642.furthest-building-you-can-reach.md

@@ -77,4 +77,4 @@ fun furthestBuilding(heights: IntArray, bricks: Int, ladders: Int): Int {
 ```
 
 * **Time Complexity**: `O(n lg k)`, `k` is the number of ladders.
-* **Space Complexity**: `O(lg k)`
+* **Space Complexity**: `O(k)`

leetcode/198.house-robber.md

@@ -2,23 +2,6 @@
 
 For the house of `i` we have two choises: robber the `i-2` and `i` house or robber `i-1` house and can't robber `i` house, then we find the maximum between the two choices.
 
-### Top-Down Recursion
-```kotlin
-fun rob(nums: IntArray): Int {
-    return rob(nums, nums.size - 1)
-}
-
-private fun rob(nums: IntArray, i: Int): Int {
-    if (i == 0) {
-        return nums[0]
-    } else if (i == 1) {
-        return max(nums[0], nums[1])
-    } else {
-        return max(rob(nums, i - 1), rob(nums, i - 2) + nums[i])
-    }
-}
-```
-
 ### Top-Down DP
 ```kotlin
 fun rob(nums: IntArray): Int {
@@ -27,6 +10,8 @@ fun rob(nums: IntArray): Int {
 }
 
 private fun rob(nums: IntArray, i: Int, memo: IntArray): Int {
+    // It's fine to write the base case: if(i < 0) return 0
+
     if (i == 0) {
         return nums[0]
     } else if (i == 1) {

leetcode/264.ugly-number-ii.md

@@ -53,7 +53,7 @@ fun nthUglyNumber(n: Int): Int {
         val num3 = dp[p3] * 3
         val num5 = dp[p5] * 5
 
-        dp[i] = min(num2, min(num3, num5))
+        dp[i] = minOf(num2, minOf(num3, num5))
 
         // Determine where does dp[i] come from, and increment the pointer
         if (dp[i] == num2) p2++

leetcode/347.top-k-frequent-elements.md

@@ -10,12 +10,19 @@
 ```
 Input: nums = [1,2,2,3,3,3], k = 1 or 2 or 3
 Output: [3] or [2, 3] or [1, 2, 3]
+
+Input: nums = [1,1,1,2,2,2,3,3,4], k = 2
+Output: [1, 2], not [1, 2, 3]
+1: 3
+2: 3  k = 2
+3: 2
+4: 1
 ```
 ### Edge / Corner Cases
 * Multiple answers. (Not gonna happen, it is guaranteed that the answer is unique.)
 ```
-Input: nums = [1,1,1,2,2,2], k = 2
-Output: 
+nums = [1,1,1,2,2,2], k = 1
+nums = [1,1,1,2,2,3,3] k = 2
 ```
 
 ## Heap
@@ -47,7 +54,7 @@ fun topKFrequent(nums: IntArray, k: Int): IntArray {
 * **Space Complexity**: `O(n) + O(k)` for hash table and heap respectively, total takes `O(n)` time.
 
 ## Bucket Sort
-We count the frequency of each element, then we create a bucket of size `nums.size + 1`, store the element value at the index `[frequency]` in the bucket. 
+We have size `n`, and we have `n` unique elements, the maximum frequency is `n`. We can count the frequency of each element, then we create a bucket of size `nums.size + 1`, store the element value at the index `[frequency]` in the bucket. 
 
 ```js
 nums = [1,2,3,4,1,2,2,3,3,3]
@@ -65,6 +72,19 @@ bucket = [
     [2],    // 3 frequency, which is 2
     [3]     // 4 frequency, which is 3
 ]
+
+// Or
+nums = [1,1,1,1]
+frequency = {
+    1: 4
+}
+bucket = [
+    [],     // 0 frequency
+    [],     // 1 frequency
+    [],     // 2 frequency
+    [],     // 3 frequency
+    [1]     // 4 frequency, which is 1
+]
 ```
 
 Then we iterate the bucket from the end to the start, and add the value to the result list.
@@ -105,6 +125,7 @@ fun topKFrequent(nums: IntArray, k: Int): IntArray {
         if (bucketList.getOrNull(i) == null) continue
         else {
             results.addAll(bucketList.get(i))
+            // The answer guaranteed to be unique, so we can break the loop when we have enough k elements.
             if (results.size >= k) break
         }
     }

leetcode/35.search-insert-position.md

@@ -28,7 +28,7 @@ Output: 5
 ```
 
 ## Binary Search
-To find the target value or the index to insert, then it indicates that we're going to search **the smallest number which is equals to or greater than `target`**.
+To find the target value or the index to insert, then it indicates that we're going to search **the smallest number which is equals to or greater than `target`** (it's *"floor", "left bound"*).
 
 ```js
 [1, 3, 5, 6], target = 5
@@ -121,7 +121,10 @@ target      L
 > 
 > https://leetcode.cn/problems/search-insert-position/solutions/8017/hua-jie-suan-fa-35-sou-suo-cha-ru-wei-zhi-by-guanp/comments/1079722
 
-**Another Important Idea!!** Or you can think in this way, **we are looking for the first element that satifies the condition `target <= num`, our condition is `target <= num`**. and we have the following array, `X` indicates the numbers that doesn't meet the condition (the numbers < `target`), and `O` indicate the number met the condition (the numbers >= `target`), then the smallest number which is equals to or greater than `target` is the first `O` we want:
+## Alternative Thinking
+**Another Important Idea!!** 
+
+Or you can think in this way, **we are looking for the first element that satifies the condition `target <= num`, our condition is `target <= num`**. and we have the following array, `X` indicates the numbers that doesn't meet the condition (the numbers < `target`), and `O` indicate the number met the condition (the numbers >= `target`), then the smallest number which is equals to or greater than `target` is the first `O` we want:
 ```js
 [X, X, X, O, O, O, O]
           ^ // target
@@ -152,6 +155,16 @@ private fun meetCondition(target: Int, num: Int): Boolean {
 }
 ```
 
+### Possible `left` Range
+The `left` pointer is in the range `[0, size]`:
+```js
+[O, O, O, O]
+ ^ // target
+
+[X, X, X, X], n
+              ^ // target 
+```
+
 ### Example
 > Try the example with only 2 element.
 ```js
@@ -167,8 +180,24 @@ Target            Insert Position
 ```
 
 ## Bonus
-How to find the last element which is <= `target` (Not the insert position)? => We search the last element that satisfies the condition `num <= target`. (The possible range is `[-1, size - 1]`)
+How to find the last element which is <= `target` (It' *"ceiling" or "right bound"*, not the insert position)? 
+
+It's the pattern:
+```js
+[O, O, O, X, X, X, X]
+       ^ // target
+```
+We search the last element that satisfies the condition `num <= target`. (The possible range is `[-1, size - 1]`)
 
+```js
+-1, [X, X, X, X]
+ ^ // target
+
+[O, O, O, O]
+          ^ // target
+```
+
+### Example
 ```js
 [1, 3, 7] target = 5
  O  O  X
@@ -178,7 +207,7 @@ How to find the last element which is <= `target` (Not the insert position)? =>
  O  O  O  O
           ^
 
-   [7, 7, 7] target = 5 // return -1
+-1 [7, 7, 7] target = 5 // return -1
     X  X  X
  ^
     L
@@ -235,36 +264,4 @@ fun search(nums: IntArray, target: Int): Int {
 private fun meetCondition(target: Int, num: Int): Boolean {
     return num <= target
 }
-```
-
-----
-### Deprecated Notes
-> The following explanation might be confused, it's OK to skip it.
-
-Remember that the `left` and `right` is the valid search range (inclusive), there are the following cases:
-1. `middle == target`: we find the target, return the index.
-2. `middle < target`: we should search the right part.
-```js
-[X, X, X, O, O, O, O]
-    M
-    | -> 
-       L           R
-```
-3. `target < middle`: we should search the left part.
-
-The most hard part is case 3. `target < middle`, because we are not sure if the `middle` is the smallest number >= `target`, so we keep searching the left part:
-```js
-[X, X, X, O, O, O, O]
-                M
-             <- |
- L           R       // Next round search range should be.
-```
-
-After several searching round, suppose we reach (but we don't know) the smallest number >= `target`, what range should we search for next round? Again, we are not sure if the `middle` is the smallest number >= `target`, so we search the left part:
-```js
-[X, X, X, O, O, O, O]
-          M 
-       <- | ->
-       R  L
-```
-And this time, it breaks the while loop, and `left` pointer is the index of the smallest number >= `target`, so we return `left`.
+```

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

@@ -2,16 +2,19 @@
 
 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:
 
+* `to(i)` represents the cost to `i-th` step, then we calculate `to(n)`.
+* `from(i)` represents the cost from `i-th` step, then we calculate `min(from(n - 1), from(n - 2))`.
+
 ```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`.
+* To `0` or `1` step cost 0, we don't have to zero cost to `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]`.
+* We calculate `to(n)` for the result.
 
 ```kotlin
 // Recursive with memoization
@@ -21,6 +24,7 @@ fun minCostClimbingStairs(cost: IntArray): Int {
     return to(cost, cost.size)
 }
 
+// Top-Down DP
 private fun to(cost: IntArray, i: Int): Int {
     if (i == 0 || i == 1) return 0
     if (memo.containsKey(i)) return memo[i]!!
@@ -39,10 +43,28 @@ fun minCostClimbingStairs(cost: IntArray): Int {
     }
     return dp[n]
 }
+
+// Space Optimization
+fun minCostClimbingStairs(cost: IntArray): Int {
+    if (cost.size == 2) return min(cost[0], cost[1])
+    
+    var result = 0
+    var step2 = 0
+    var step1 = 0
+    for (i in 2..cost.size) {
+        result = min(step1 + cost[i - 1], step2 + cost[i - 2])
+        step2 = step1
+        step1 = result
+    }
+    return result
+}
 ```
 
 ### `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])`.
+The `from(i)` / `dp[i]` represents the cost **from** i-th step:
+* To `0` or `1` step cost `cost[0]` and `cost[1]`.
+* The cost from `i-th` step will be (the minimum of `from(i - 2)` and `from(i - 1)`) + `cost[i]`.
+* We calculate the minimum of `from(i - 2)` and `from(i - 1)` for the result.
 
 ```kotlin
 // Time Complexity: O(n)
@@ -62,18 +84,21 @@ fun minCostClimbingStairs(cost: IntArray): Int {
 // 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])
+fun from(cost: IntArray): Int {
+    val n = cost.size
+    // n - 1
+    var n1 = cost[1]
+    // n - 2
+    var n2 = cost[0]
 
     var result = 0
-    var step2 = 0
-    var step1 = 0
-    for (i in 2..cost.size) {
-        result = min(step1 + cost[i - 1], step2 + cost[i - 2])
-        step2 = step1
-        step1 = result
+    for (i in 2 until n) {
+        // from(i) = cost(i) + min(from(i - 1), from(i - 2))
+        result = cost[i] + minOf(n1, n2)
+        n2 = n1
+        n1 = result
     }
-    return result
+    return minOf(n2, n1)
 }
 ```
 

leetcode/array-problems.md

@@ -32,6 +32,7 @@
 > * https://leetcode.com/problems/maximum-performance-of-a-team/ 3k h
 > * https://leetcode.com/problems/minimize-deviation-in-array/ 2k h
 
+
 ### Two Pointers
 | Problem          | Difficulty |
 |------------------|------------|
@@ -98,6 +99,7 @@
 
 > Study guidelines: https://leetcode.com/discuss/study-guide/2166045/ (Have reviwed the problem listing)
 > Listing: https://leetcode.com/problem-list/52dlem1s/
+> Video: https://www.bilibili.com/video/BV1qY411n7Qs/?vd_source=2f62e0e1762a6703c96771d3baa35968
 > * https://leetcode.cn/problems/my-calendar-i/solutions/1646264/by-jiang-hui-4-pyfn/
 > * https://leetcode.com/problems/non-overlapping-intervals/description/ 8k m
 > * https://leetcode.com/problems/number-of-flowers-in-full-bloom  1k h

topics/binary-search.md

@@ -1,7 +1,7 @@
 # Binary Search
 
 ## Normal
-The binary search is applicable when the collection is **sorted**, so try to sort the collection if it's not sorted yet.
+The binary search is applicable when the collection is **sorted** or the search range satisfies **monotonicity** characteristic. In this implementation, we're using inclusive range `[left, right]` to represent the searching range, and we break out the while loop when `left > right`. (The searching range is empty)
 
 ```kotlin
 fun binarySearch(A: IntArray, target: Int): Int {
@@ -61,26 +61,30 @@ O O O O O O X X X
           ^ // The last element that satifies the condition
 ```
 
-For example, to find the smallest (largest) number which is greater (smaller) or equal to the target: For the two problems (might contain duplicates), we can use the same conditions when `target != middle` (`<`, `>`) as normal binary search, the different part is when `target == middle`:
+For example, to find the smallest (largest) number which is greater (smaller) or equal to the target: For the two problems (might contain duplicates), we can use the same conditions when `target < middle` and `middle < target` as normal binary search, the different part is when `target == middle`:
 
-* To find the smallest number >= `target`, we should keep searching the left half part, and return `left` pointer when while loop breaks.
+* To find the smallest number >= `target` (`target <= num`), we should keep searching the left half part, and return `left` pointer when while loop breaks.
 ```js
-          (X, _, _, _, ...)
-target <=    
-           L          R        
+// When breaking the while loop, the position of pointers:
+[X, X, X, O, O, O, O]
+          L
+          M
+       R
 ```
 
-* To find the largest number <= `target`, we should search the right half part, and return `right` pointer when while loop breaks.
+* To find the largest number <= `target`, we should keep searching the right half part, and return `right` pointer when while loop breaks.
 ```js
-(..., _, _, X)          
-               <= target
- L          R 
+// When breaking the while loop, the position of pointers:
+[O, O, O, O, X, X, X]
+             L
+          M
+          R
 ```
 
 > Sample problem: [35. Search Insert Position](../leetcode/35.search-insert-position.md)
 
 ## Find the First/Last Position of Element in Sorted Array
-Given sorted array (might contain duplicates), we can use the same approach mentioned above to find the first/last position of element in sorted array. We apply the same conditions when `target != middle` (`<`, `>`) as normal binary search, the different part is when `target == middle`:
+Given sorted array (might contain duplicates), we can use the same approach mentioned above to find the first/last position of element in sorted array. We apply the same conditions when `target < middle` and `middle < target` as normal binary search, the different part is when `target == middle`:
 
 * To find the first position, we should keep searching the left part because we don't know if current `middle` is the first element, and return `left` pointer when while loop breaks.
 ```js