Add and update some notes and problem solving solutions

Author: enginebai

leetcode/1.two-sum.md

@@ -17,6 +17,7 @@ def twoSum(self, nums: List[int], target: int) -> List[int]:
 ```kotlin
 fun twoSum(nums: IntArray, target: Int): IntArray {
     val results = IntArray(2)
+    // value, index
     val hashTable = hashMapOf<Int, Int>()
     for (i in 0 until nums.size) {
         val num = nums[i]

leetcode/1011.capacity-to-ship-packages-within-d-days.md

@@ -0,0 +1 @@
+#[1011. Capacity To Ship Packages Within D Days](https://leetcode.com/problems/capacity-to-ship-packages-within-d-days/)

leetcode/128.longest-consecutive-sequence.md

@@ -96,10 +96,12 @@ fun longestConsecutive(nums: IntArray): Int {
         // If we have num - 1 which is consecutive to num, answer will check at num - 1 iteration, not current iteration.
         if (!hashSet.contains(num - 1)) {
             var next = num + 1
+            var length = 1
             while (hashSet.contains(next)) {
                 next++
+                length++
             }
-            maxStreak = max(maxStreak, next - num)
+            maxStreak = max(maxStreak, length)
         }
     }
     return maxStreak

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

@@ -16,16 +16,22 @@ def countNegatives(self, grid: List[List[int]]) -> int:
 * **Time Complexity**: `O(m * n)`.
 * **Space Complexity**: `O(1)`.
 
-## Count in Z-shape
+## Count in Z-Shape
 Since each row (column) is sorted, we can count the negative numbers in a Z-shape.
 
-```
-++++++
-++++--
-++++--
-+++---
-+-----
-+-----
+```js
+X X X O
+X O O O
+O O O O
+
+// All are negative numbers
+O O O 
+O O O
+
+// All are positive numbers
+X X X
+X X X
+
 ```
 
 ![](../media/240.search-a-2d-matrix-ii.png)
@@ -40,6 +46,9 @@ def countNegatives(self, grid: List[List[int]]) -> int:
     r = m - 1
     c = 0
     count = 0
+    # We don't check if r < 0, becase r will become -1 but we still need to count the following columns. See the example below (all numbers are negative):
+    # -1, -1, -1
+    # -1, -1, -1
     while c < n:
         while 0 <= r and grid[r][c] < 0:
             r -= 1
@@ -74,7 +83,6 @@ 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

leetcode/139.word-break.md

@@ -5,20 +5,24 @@
 // 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
+
+f(ca) =
+    f(c) + "a" in dict ||
+    f() + "ca" in dict
+
+f(c) = 
+    f() + "c" in dict
 ```
 
 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 (`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.
+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 the subproblem of `s[0:i]`: `s[0:i] = 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.
@@ -77,20 +81,51 @@ private fun breakdown(s: String, dict: HashSet<String>, memo: HashMap<String, Bo
 In bottom-up approach, We build the solution from smaller substrings to the entire string. 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
+// s = [0.....j.....i]
+//     [0...  j] 
+//              s[j:i]
 // The state of s[0:i] = s[0:j] + s[j:i]
 dp[i] = 
     dp[j]       // The state of s[0:j], 
     && s[j:i]   // The remaining substring, check if it in the dictionary
+
+// We iterate j from 0 to i to build the dp[i]
+dp[i] = 
+    dp[0] && s[0:i] in dict ||
+    dp[1] && s[1:i] in dict ||
+    dp[2] && s[2:i] in dict ||
+    ...
+    dp[i - 1] && s[i - 1:i] in dict
 ```
-We will iterate `i` from 0 to `len` for find if we can build substring `s[0:i]`.
 
-For example, `"cars"` and `["car", "ca", "rs"]`:
+We will iterate `i` from 0 to `len` to build the `dp[i]` table from bottom up, and for each `i`, we iterate `j` from 0 to `i` to build the `dp[i]` from `dp[j]` and `s[j:i]` in dictionary.
+```js
+// i = 0, empty string
+dp[0] = true // Base case, empty string is in dictionary
+
+// i = 1, s[0:1]
+dp[1] = dp[0] && s[0:1] in dict
 
-> The following iterate cooresponds to the nested for loop in the code. `i` is `end` and `j` is `start`.
+// i = 2, s[0:2]
+dp[2] = dp[0] && s[0:2] in dict ||
+        dp[1] && s[1:2] in dict
+
+dp[3] = dp[0] && s[0:3] in dict ||
+        dp[1] && s[1:3] in dict ||
+        dp[2] && s[2:3] in dict
+
+// So on ...
+
+// i = n, s[0:n]
+dp[n] = ... // The final result
+```
+
+For example, `"cars"` and `["car", "ca", "rs"]`:
 
 ```js
       [suffix]
+dp[0] = true
+
 j  i  c a r s
 // dp[1] if we can build "c" from dictionary
 0, 1, c         // dp[0] && dict.contains("c")
@@ -113,19 +148,16 @@ j  i  c a r s
 
 ```kotlin
 fun wordBreak(s: String, wordDict: List<String>): Boolean {
-    val wordDictSet = HashSet<String>(wordDict)
+    val dict = HashSet<String>(wordDict)
     // We define dp size as s.length + 1 because the base case is empty string, that is s[0:0] = "".
     val dp = BooleanArray(s.length + 1)
     // Base case is empty string, which is true.
     dp[0] = true
-    for (end in 1..s.length) {
-        for (start in 0..end) {
-            // s[start:end] = s[0:start] + s[start:end]
-            // dp[end] = dp[start] && s[start:end] in dict
-            val suffix = s.substring(start, end)
-            if (dp[start] && wordDictSet.contains(suffix)) {
-                dp[end] = true
-                break
+    for (i in 1..s.length) {
+        // dp[i] = dp[0:j] + s[j:i] in dict
+        for (j in 0..i) {
+            if (dp[j] && dict.contains(s.substring(j, i))) {
+                dp[i] = true
             }
         }
     }

leetcode/153.find-minimum-in-rotated-sorted-array.md

@@ -52,18 +52,20 @@ fun findMin(nums: IntArray): Int {
     while (left <= right) {
         val middle = left + (right - left) / 2
         min = minOf(min, nums[middle])
-        if (nums[middle] > nums[right]) {
+        
+        // We can list all possible cases
+        if (nums[left] <= nums[middle] && nums[middle] <= nums[right]) { // O / O:  L
+            right = middle - 1
+        } else if (nums[left] <= nums[middle] && nums[middle] > nums[right]) { // O / X: R
             left = middle + 1
-        } else {
+        } else if (nums[left] > nums[middle] && nums[middle] <= nums[right]) { // X / O:  L
             right = middle - 1
         }
 
-        // Or equivalently we can list all possible cases
-        // if (nums[left] <= nums[middle] && nums[middle] <= nums[right]) { // O / O:  L
-        //     right = middle - 1
-        // } else if (nums[left] <= nums[middle] && nums[middle] > nums[right]) { // O / X: R
+        // Or equivalent: if the right part is not sorted, which is the pivot part, the minimum must be in the right part.
+        // if (nums[middle] > nums[right]) {
         //     left = middle + 1
-        // } else if (nums[left] > nums[middle] && nums[middle] <= nums[right]) { // X / O:  L
+        // } else {
         //     right = middle - 1
         // }
     }

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

@@ -60,10 +60,8 @@ fun furthestBuilding(heights: IntArray, bricks: Int, ladders: Int): Int {
             // But if we don't have enough ladder, then try to go back to change
             // the smallest height difference to use the remaining brick.
             if (ladders < minHeap.size) {
-                // We have enough bricks
-                if (minHeap.isNotEmpty() && minHeap.peek() <= remainingBricks) {
-                    remainingBricks -= minHeap.poll()
-                } else {
+                remainingBricks -= minHeap.poll()
+                if (remainingBricks < 0) {
                     // If we don't have enough bricks, then the "previous" position is the furthest we can reach.
                     // Minus 1 because we check if we can reach the "next" building in each iteration.
                     // It failed at the current iteration means that the furtherest we can reach is the previous building.
@@ -76,5 +74,5 @@ fun furthestBuilding(heights: IntArray, bricks: Int, ladders: Int): Int {
 }
 ```
 
-* **Time Complexity**: `O(n lg k)`, `k` is the number of ladders.
-* **Space Complexity**: `O(k)`
+* **Time Complexity**: `O(n lg L)`, `L` is the number of ladders.
+* **Space Complexity**: `O(L)`

leetcode/169.majority-element.md

@@ -44,10 +44,10 @@ fun majorityElement(nums: IntArray): Int {
         if (count == 0) {
             majority = nums[i]
         }
-        if (nums[i] != majority) {
-            count--
-        } else {
+        if (nums[i] == majority) {
             count++
+        } else {
+            count--
         }
     }
     return majority

leetcode/1870.minimum-speed-to-arrive-on-time.md

@@ -0,0 +1,76 @@
+# [1870. Minimum Speed to Arrive on Time](https://leetcode.com/problems/minimum-speed-to-arrive-on-time/description/)
+
+## Linear Search
+We're finding the minimum speed to reach the office on time. Let's start from speed `1`, and check if it's possible to reach the office within `hour` hours. If not, we increase the speed by 1 and check again.
+
+```js
+speed = distance / time
+time = distance / speed
+
+s = 1
+[1, 3, 2]
+ceil(1/1) + ceil(3/1) + 2/1 = 6 <= 6
+
+s = 2
+ceil(1/2) + ceil(3/2) + 2/2 = 1 + 2 + 1 = 4
+
+s = 3
+ceil(1/3) + ceil(3/3) + 2/3 = 1 + 1 + 0.66 = 2.66 <= 6
+```
+
+```kotlin
+fun minSpeedOnTime(dist: IntArray, hour: Double): Int {
+    var speed = 1
+    while (speed <= 10000000) {
+        // See below for the implementation of getTotalHours()
+        if (getTotalHours(dist, speed) <= hour) return speed
+        speed++
+    }
+    return -1
+}
+```
+
+## Binary Search
+We can optimize the linear search solution with some modifications based on some key observations:
+1. The minimum speed is `1`, and the maximum speed is the maximum of possible value, which is `10^7`.
+2. As we increase the speed, the time to reach the office is shorter, and vice versa. This exhibits the **monotonicity** characteristic, so we can use binary search to find the minimum speed: **We're looking for the first element that satisfies the condition: `getTotalHours(dist, middle) <= hour`**.
+
+```kotlin
+fun minSpeedOnTime(dist: IntArray, hour: Double): Int {
+    val min = 1
+    val max = 10000000
+
+    var left = min
+    var right = max
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+        val isValid = getTotalHours(dist, middle) <= hour
+
+        // Find the first element that meets the condition (can reach the office)
+        if (isValid) {
+            right = middle - 1
+        } else {
+            left = middle + 1
+        }
+    }
+    // We check if the left is in the range, if not, return -1
+    return if (left in min..max) left else -1
+}
+
+// We calculate the total hours to reach the office with the given speed.
+// ceil(dist[0] / speed) + ceil(dist[1] / speed) + ... + ceil(dist[n - 2] / speed) + dist[n - 1] / speed
+// The last distance doesn't need to wait, so we don't need to ceil it.
+private fun getTotalHours(dist: IntArray, speed: Int): Double {
+    var hours = 0.0
+    // We iterate all distances except the last one: because we have to wait if the hour is not an integer.
+    for (d in 0 until dist.size - 1) {
+        hours += Math.ceil(dist[d].toDouble() / speed) // If the hour is 1.5, then total hours is 2.
+    }
+    // We add the last distance to the total hours, which we don't have to wait.
+    hours += dist[dist.size - 1].toDouble() / speed
+    return hours
+}
+```
+
+* **Time Complexity:** `O(n * log m)`, where `n` is the size of the `dist` and `m` is the maximum speed.
+* **Space Complexity:** `O(1)`.

leetcode/2064minimized-maximum-of-products-distributed-to-any-store.md

@@ -0,0 +1,5 @@
+# [2064. Minimized Maximum of Products Distributed to Any Store](https://leetcode.com/problems/minimized-maximum-of-products-distributed-to-any-store/description/)
+
+```kotlin
+
+```