Add new binary search solutions

Author: enginebai

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

@@ -68,7 +68,7 @@ class Solution {
 }
 
 private fun getShipDays(weights: IntArray, capacity: Int): Int {
-    var days = 1
+    var days = 1 // We count the last group since we don't execute if statement in the last iteration. 最後一個分組一定不會執行 if 語句，但是還是要算一天。
     var load = 0
     // in the order given by weights as problem description
     for (w in weights) {

leetcode/1146.snapshot-array.md

@@ -0,0 +1,141 @@
+# [1146. Snapshot Array](https://leetcode.com/problems/snapshot-array/description/)
+
+The shapshot array is a data structure that supports the following operations:
+```js
+nums = [0, 0, 0, 0, 0]
+        |  |  |
+ set    1  3  5
+        |  |  |
+       [1, 3, 5, 0, 0]  
+        |     |         [1, 3, 5, 0, 0] // snapshot 0
+        |     |     
+ set    7     8
+        |     |
+       [7, 3, 8, 0, 0]
+                        [1, 3, 7, 8, 0] // snapshot 1
+// No update
+                        [1, 3, 7, 8, 0] // snapshot 2
+        |        |
+ set    9        2
+        |        |
+       [9, 3, 8, 2, 0]
+                        [9, 3, 8, 2, 0] // snapshot 3
+```
+Please note that
+1. We can set multiple times at the same index, but only one snapshot. Or
+2. We can snap multiple times without changing the array. (The value was not updated)
+
+## Brute Force (MLE)
+We just save all snapshots. It wastes memory if we have a large array but only a few elements are modified.
+
+```kotlin
+class SnapshotArray(private val length: Int) {
+
+    private var currentSnapId = 0
+
+    private val array = IntArray(length)
+    private val snapshot = mutableListOf<IntArray>()
+
+    fun set(index: Int, `val`: Int) {
+        array[index] = `val`
+    }
+
+    fun snap(): Int {
+        snapshot.add(array.clone())
+        return currentSnapId++
+    }
+
+    fun get(index: Int, snap_id: Int): Int {
+        return snapshot[snap_id][index]
+    }
+}
+```
+
+## Binary Search
+The history of the array is saved in the snapshot. Instead of saving all snapshots, we can save only the changes. 
+
+```js
+nums = [0, 0, 0, 0, 0]
+        |  |  |
+ set    1  3  5
+        |  |  |
+       [1, 3, 5, 0, 0]  // snapshot 0
+        |     |     
+ set    7     8
+        |     |
+       [7, 3, 8, 0, 0]  // snapshot 1
+// No update
+       [7, 3, 8, 0, 0]  // snapshot 2
+        |        |
+ set    9        2
+        |        |
+       [9, 3, 8, 2, 0]  // snapshot 3
+```
+
+We only record the modified elements when `set()` is called. 
+```js
+// For nums[0]
+0 -> 1 -> snapshot 0 -> 7 -> snapshot 1 -> snapshot 2 -> 9 -> snapshot 3
+0 --------------------> 1 -------------> 7 ------------> 7 ----------> 9
+
+           0                             1                      3
+|--------- 1 -----------|--------------- 7 --------------|----- 9 -----|
+
+// Add modification records for nums[0]
+record(snap_id=0, 1)
+record(snap_id=1, 7)
+record(snap_id=3, 9)
+
+// The corresponding get() for nums[0] at different snapshots
+get(snap_id=0) = 1
+get(snap_id=1) = 7
+get(snap_id=2) = 7 // No update
+get(snap_id=3) = 9
+
+```
+When we call `get()`, we can binary search the snapshot to find the closest snapshot, we're looking for **the last snapshot <= `snap_id`**.
+
+```kotlin
+data class Item(
+    val snapId: Int,
+    val value: Int
+)
+
+class SnapshotArray(private val length: Int) {
+
+    private var currentSnapId = 0
+    // Space Complexity is `O(n + k)` where `n` is the length of the array and `k` is the number of modifications.
+    private val modificationRecords = Array<MutableList<Item>>(length) { mutableListOf() }
+
+    // Time Complexity is `O(1)`
+    fun set(index: Int, `val`: Int) {
+        modificationRecords[index].add(Item(currentSnapId, `val`))
+    }
+
+    // Time Complexity is `O(1)`
+    fun snap(): Int {
+        return currentSnapId++
+    }
+
+    // Time Complexity is `O(log(k))` where `k` is the number of modifications.
+    fun get(index: Int, snap_id: Int): Int {
+        return binarySearch(modificationRecords[index], snap_id)
+    }
+
+    private fun binarySearch(records: List<Item>, snapId: Int): Int {
+        var left = 0
+        var right = records.size - 1
+        while (left <= right) {
+            val middle = left + (right - left) / 2
+            if (records[middle].snapId < snapId) {
+                left = middle + 1
+            } else if (records[middle].snapId > snapId) {
+                right = middle - 1
+            } else if (records[middle].snapId == snapId) {
+                left = middle + 1
+            }
+        }
+        return if (right in 0 until records.size) records[right].value else 0
+    }
+}
+```

leetcode/1443.minimum-time-to-collect-all-apples-in-a-tree.md

@@ -0,0 +1,80 @@
+# [1443. Minimum Time to Collect All Apples in a Tree](https://leetcode.com/problems/minimum-time-to-collect-all-apples-in-a-tree/description/)
+
+## DFS
+```js
+//  1.          2.		 	3.   	    4.
+    X           O           X           O
+  /   \       /   \       /   \       /   \
+ X     X     X     X     O     X     O     X
+
+1. No any apple
+2. Apple at root
+3. Apple at child
+4. Apple at root and child
+```
+
+> Solved by tree (but need to build tree from edges) or graph approach (to mark visited)
+
+```kotlin
+fun minTime(n: Int, edges: Array<IntArray>, hasApple: List<Boolean>): Int {
+        val tree = buildTree(edges)
+        return dfs(tree, 0, hasApple, 0, BooleanArray(n))
+    }
+
+    private fun buildTree(edges: Array<IntArray>): HashMap<Int, HashSet<Int>> {
+        val tree = HashMap<Int, HashSet<Int>>()
+        for (e in edges) {
+            // a -> b
+            val a = e[0]
+            val b = e[1]
+            if (!tree.containsKey(a)) tree[a] = HashSet<Int>()
+            if (!tree.containsKey(b)) tree[b] = HashSet<Int>()
+            tree[a]!!.add(b)
+            tree[b]!!.add(a)
+        }
+        return tree
+    }
+
+    private fun dfs(
+        tree: HashMap<Int, HashSet<Int>>, 
+        root: Int, 
+        hasApple: List<Boolean>, 
+        distance: Int,
+        visited: BooleanArray
+    ): Int {
+        if (visited[root]) return 0
+        visited[root] = true
+        var childrenDistance = 0
+
+        tree[root]?.forEach { child ->
+            childrenDistance += dfs(tree, child, hasApple, 2, visited)
+        }
+        if (childrenDistance == 0 && hasApple[root] == false) return 0
+        else return childrenDistance + distance
+    }
+}
+```
+
+* From GPT, different approach from above.
+```python
+def minTime(n, edges, hasApple):
+    from collections import defaultdict
+
+    # Build the graph
+    graph = defaultdict(list)
+    for u, v in edges:
+        graph[u].append(v)
+        graph[v].append(u)
+
+    def dfs(node, parent):
+        total_time = 0
+        for neighbor in graph[node]:
+            if neighbor == parent:
+                continue
+            time = dfs(neighbor, node)
+            if time > 0 or hasApple[neighbor]:
+                total_time += time + 2
+        return total_time
+
+    return dfs(0, -1)
+```

leetcode/1482.minimum-number-of-days-to-make-m-bouquets.md

@@ -0,0 +1,105 @@
+# [1482. Minimum Number of Days to Make m Bouquets](https://leetcode.com/problems/minimum-number-of-days-to-make-m-bouquets/)
+
+## Binary Search
+For this problem, the minimum number of days to wait is the minimum value in the array, and the maximum number of days to wait is the maximum value in the array.
+
+```js
+// m = 1, k = 3 or m = 3, k = 1
+days    [1, 5, 3]   can make?
+1       [O, X, X]   X
+2       [O, X, X]   X
+3       [O, X, O]   X
+4       [O, X, O]   X
+5       [O, O, O]   O <- answer
+6       [O, O, O]   O
+...
+
+days    [7, 7, 9]
+1       [X, X, X]   X
+2       [X, X, X]   X
+...
+7       [O, O, X]   X
+8       [O, O, X]   X
+9       [O, O, O]   O <- answer
+10      [O, O, O]   O
+...
+```
+
+And if we can make it when waiting for `d` days, then we can also make it when waiting for `d+1`, `d+2`, ..., `max(days)` days. If we can't make it when waiting for `d` days, then we can't make it when waiting for `d-1`, `d-2`, ..., `min(days)` days. This is monotonicity, so we can use binary search to find the answer.
+
+```kotlin
+fun minDays(bloomDay: IntArray, m: Int, k: Int): Int {
+    val n = bloomDay.size
+    if (n < m * k) return -1
+
+    var min = Int.MAX_VALUE
+    var max = Int.MIN_VALUE
+    for (b in bloomDay) {
+        min = minOf(min, b)
+        max = maxOf(max, b)
+    }
+
+    var left = min
+    var right = max
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+
+        if (canMake(bloomDay, middle, m, k)) {
+            right = middle - 1
+        } else {
+            left = middle + 1
+        }
+    }
+    // Remember to check if left is out of bound. That is the case
+    // [X, X, X]
+    //           ^ left
+    return if (left > max) -1 else left
+}
+
+private fun canMake(bloomDay: IntArray, day: Int, m: Int, k: Int): Boolean {
+    var numOfBouquets = 0
+    var count = 0
+    for (i in 0 until bloomDay.size) {
+        if (bloomDay[i] <= day) {
+            count++
+        } else {
+            count = 0
+        }
+
+        if (count == k) {
+            numOfBouquets++
+            count = 0
+        }
+    }
+    return m <= numOfBouquets
+}
+
+// Or equivalently
+private fun canMake(bloomDay: IntArray, day: Int, m: Int, k: Int): Boolean {
+    var i = 0
+    var numOfBouquets = 0 // If we can make `m` bouquets
+    while (i < bloomDay.size) {
+        val canBloom = bloomDay[i] <= day
+        if (!canBloom) {
+            i++
+            continue
+        }
+
+        var j = i
+        var count = 0 // If we can use `k` flowers to make a bouquet
+        // If we can bloom, and not enough flowers to make the current bouquet
+        while (j < bloomDay.size && count < k && bloomDay[j] <= day) {
+            count++
+            j++
+        }
+        if (k <= count) {
+            numOfBouquets++
+        }
+        i = j
+    }
+    return m <= numOfBouquets
+}
+```
+
+* **Time Complexity:** `O(log(max(days) - min(days)) * n)`
+* **Space Complexity:** `O(1)`