Update notes and problem solutions

Author: enginebai

leetcode/100.same-tree.md

@@ -18,11 +18,13 @@ Output: True
 ```
 ### Edge / Corner Cases
 * Values are the same, but different structurely.
-```
+```js
 Input: 
     1
   /   
  2  
+
+// Or
     1
       \
        2
@@ -50,8 +52,8 @@ fun isSameTree(p: TreeNode?, q: TreeNode?): Boolean {
 }
 ```
 
-* **Time Complexity**: `O(min(P, Q))`, where `P` and `Q` are the number of tree nodes of `p` and `q`.
-* **Space Complexity**: `O(min(P, Q))`
+* **Time Complexity**: `O(min(P, Q))`, where `P` and `Q` are the number of tree nodes of `p` and `q`, we terminate the recursion when we reach the end of the smaller tree.
+* **Space Complexity**: `O(min(Hp, Hq))`, where `Hp` and `Hq` are the height of the tree of `p` and `q`.
 
 ## Iterative
 ```kotlin

leetcode/101.symmetric-tree.md

@@ -79,4 +79,22 @@ fun isSymmetric(root: TreeNode?): Boolean {
 }
 ```
 * **Time Complexity**: `O(n)`, where `n` is the number of tree nodes.
-* **Space Complexity**: `O(n)`, where `n` is the number of tree nodes.
+* **Space Complexity**: `O(n)`, where `n` is the number of tree nodes.
+
+## Symmetric 3-ary Tree
+```kotlin
+fun isSymmetric(root: TreeNode?): Boolean {
+    if (root == null) return true
+    return check(root.left, root.right) && isSymmetric(root.center)
+}
+
+private fun check(left: TreeNode?, right: TreeNode?): Boolean {
+    if (left == null && right == null) return true
+    if (left == null || right == null) return false
+    return (left.`val` == right.`val`) &&
+        check(left.left, right.right) && 
+        check(left.right, right.left) &&
+        isSymmetric(left.center) &&
+        isSymmetric(right.center)
+}
+```

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

@@ -1 +1,100 @@
-#[1011. Capacity To Ship Packages Within D Days](https://leetcode.com/problems/capacity-to-ship-packages-within-d-days/)
+# [1011. Capacity To Ship Packages Within D Days](https://leetcode.com/problems/capacity-to-ship-packages-within-d-days/)
+
+## Linear Search
+We can start linear search by iterating the capacity from 1 and find the first capacity that can ship all packages within `days`.
+
+```js
+days = 3
+capacity 1, 2, 3, 4, 5    day
+
+1       [1, 2, 3, 4, 5] = 15  X
+2       [1, 1, 2, 2, 3] = 9   X
+3       [   1, 1, 2, 2] = 6   X
+4       [   1, 1, 1, 2] = 5   X
+5       [   1, 1, 1, 1] = 4   X
+6       [      1, 1, 1] = 3   O <- the least weight capacity
+
+...
+10      [         1, 1] = 2   O
+
+...
+15      [            1] = 1   O
+```
+
+## Binary Search
+But we can optimize the solution with some key observations:
+
+The intuition is that without considering the limiting days `D`, we can ship all packages in one day with the maximum weight.
+
+```js
+[1, 2, 3, 4, 5], max = 5 
+
+=> [1, 2] [3] [4] [5]
+```
+
+To ship exactly `D` days and minimize the max sum of any partition, we're looking for the minimal one among all feasible capacities. If we can ship all packages within `D` days, then we can definitely ship them with a larger capacity. If we can't ship all packages within `D` days, then we can't ship them with a smaller capacity.
+
+1. The minimum capacity is the maximum of the weights, because we can't ship the package with the capacity less than the maximum weight.
+2. The maximum capacity is the sum of the weights because we can ship all packages in one day.
+3. As we increase the capacity, the shipped days decreases, and vice versa. This exhibits the **monotonicity** characteristic, so we can use binary search to find the minimum capacity: **We're looking for the first element that satisfies the condition: `shipDays(weights, middle) <= days`**.
+
+For `shipDays(weights, capacity)`, we can calculate the days needed to ship all packages with the given capacity. We iterate the weights and accumulate the weight greedily before it exceeds the capacity. If it exceeds the capacity, we increment the days and reset the load to the current weight.
+
+```kotlin
+class Solution {
+    fun shipWithinDays(weights: IntArray, days: Int): Int {
+        var max = Int.MIN_VALUE
+        var sum = 0
+        for (w in weights) {
+            max = maxOf(max, w)
+            sum += w
+        }
+
+        var left = max
+        var right = sum
+        while (left <= right) {
+            val middle = left + (right - left) / 2
+            val canShipped = shippedDays(weights, middle) <= days
+            // capacity 
+            // X X X O O O O O
+            if (canShipped) {
+                right = middle - 1
+            } else {
+                left = middle + 1
+            }
+        }
+        return left
+    }
+}
+
+private fun getShipDays(weights: IntArray, capacity: Int): Int {
+    var days = 1
+    var load = 0
+    // in the order given by weights as problem description
+    for (w in weights) {
+        if (load + w > capacity) {
+            days++
+            load = 0
+        }
+        load += w
+    }
+    return days
+}
+
+// or equivalently
+private fun getShipDays(weights: IntArray, capacity: Int): Int {
+    var days = 1
+    var load = 0
+    for (w in weights) {
+        load += w
+        if (load > capacity) {
+            days++
+            load = w
+        }
+    }
+    return days
+}
+```
+
+* **Time Complexity:** `O(n log m)`, where `n` is the number of weights and `m` is the sum of the weights.
+* **Space Complexity:** `O(1)`.

leetcode/103.binary-tree-zigzag-level-order-traversal.md

@@ -47,4 +47,7 @@ fun zigzagLevelOrder(root: TreeNode?): List<List<Int>> {
 
     return results
 }
-```
+```
+
+* **Time Complexity**: `O(n)`
+* **Space Complexity**: `O(n)`

leetcode/1038.binary-search-tree-to-greater-sum-tree.md

@@ -78,8 +78,10 @@ private fun build(root: TreeNode?, value: Int): Int {
     // Root 4 will receive 19, not 14. Because 21 is the sum of 5, 6, 8.
     return currentSum
 }
+```
 
-// Or equivalently, we can maintain a global variable to store the sum.
+Or equivalently, we can maintain a global variable to store the sum.
+```kotlin
 private var sum = 0
   fun bstToGst(root: TreeNode?): TreeNode? {
       inorder(root)

leetcode/104.maximum-depth-of-binary-tree.md

@@ -43,7 +43,7 @@ fun maxDepth(root: TreeNode?): Int {
 ```
 
 * **Time Complexity**: `O(n)`, we traverse all nodes once.
-* **Space Complextiy**: `O(H)`, recursion need space for stack, and the space depends on the height of the tree. The height might be `lg n` (balanced) or `n` (skewed)
+* **Space Complextiy**: `O(h)`, recursion need space for stack, and the space depends on the height of the tree. The height might be `lg n` (balanced) or `n` (skewed)
 
 ### BFS
 ```kotlin
@@ -65,4 +65,4 @@ fun maxDepth(root: TreeNode?): Int {
 }
 ```
 * **Time Complexity**: `O(n)`, we traverse all nodes once.
-* **Space Complexity**: `O(n)`, we traverse all nodes in queue.
+* **Space Complexity**: `O(n)`, we enqueue all nodes in the queue.

leetcode/111.minimum-depth-of-binary-tree.md

@@ -91,7 +91,7 @@ fun minDepth(root: TreeNode?): Int {
 }
 ```
 * **Time Complexity**: `O(n)`, iterate all nodes.
-* **Space Complexity**: `O(n)`, the worst case is the tree is a linked list, so the recursion stack will store all nodes.
+* **Space Complexity**: `O(h)`, the worst case is the tree is a linked list, so the recursion stack will store all nodes, which is `O(n)`.
 
 ## BFS
 We traversal level by level, and search the first leaf node, then return the depth.

leetcode/114.flatten-binary-tree-to-linked-list.md

@@ -150,6 +150,8 @@ private fun subtreeLast(root: TreeNode): TreeNode {
 ## Preorder with Pointers (Space Optimization)
 Idea is the same, but we traversal with pointers only (removing stack or recursion).
 
+> Nice illustration: https://leetcode.cn/problems/flatten-binary-tree-to-linked-list/solutions/356853/er-cha-shu-zhan-kai-wei-lian-biao-by-leetcode-solu/
+
 ```kotlin
 fun flatten(root: TreeNode?): Unit {
     if (root == null) return

leetcode/116.populating-next-right-pointers-in-each-node.md

@@ -16,9 +16,9 @@ Input:
 Output: 
       1 -> null
     /   \
-   2  -> 3 -> null
+   2 --> 3 -> null
   / \   / \
- 4-> 5 6-> 7 -> null
+ 4-> 5>6-> 7 -> null
 ```
 ### Edge / Corner Cases
 * Empty or single node tree

leetcode/1254.number-of-closed-islands.md

@@ -136,4 +136,7 @@ class Solution {
         }
     }
 }
-```
+```
+
+* **Time Complexity**: `O(m * n)`.
+* **Space Complexity**: `O(m * n)`.

leetcode/1315.sum-of-nodes-with-even-valued-grandparent.md

@@ -101,4 +101,7 @@ private fun dfs(root: TreeNode?, parent: TreeNode?, grandparent: TreeNode?) {
     dfs(root.left, root, parent)
     dfs(root.right, root, parent)
 }
-```
+```
+
+* **Time Complexity**: `O(n)`.
+* **Space Complexity**: `O(n)`.

leetcode/133.clone-graph.md

@@ -62,6 +62,7 @@ private fun clone(node: Node?): Node? {
     val newNode = Node(node.`val`)
     oldNewMapping[node] = newNode
     node.neighbors.forEach { adj ->
+        // Clone the neighbors during the DFS traversal recursively.
         newNode.neighbors.add(clone(adj))
     }
     return newNode

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

@@ -32,9 +32,11 @@ fun minSpeedOnTime(dist: IntArray, hour: Double): Int {
 
 ## 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`.
+1. The minimum speed is `1`, and the maximum speed is the maximum of possible value, which is `10^7` (based on the problem constraints).
 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`**.
 
+> It's a little bit confused why we don't ceil the last distance, maybe just skip it.
+
 ```kotlin
 fun minSpeedOnTime(dist: IntArray, hour: Double): Int {
     val min = 1
@@ -55,6 +57,8 @@ fun minSpeedOnTime(dist: IntArray, hour: Double): Int {
     }
     // We check if the left is in the range, if not, return -1
     return if (left in min..max) left else -1
+    // Or
+    // return if (left > max) -1 else left
 }
 
 // We calculate the total hours to reach the office with the given speed.

leetcode/2115.find-all-possible-recipes-from-given-supplies.md

@@ -18,36 +18,24 @@ Output:
 
 Suppose we the following recipes, ingredients and supplies:
 ```js
-Recipes = [R2, R1]
-Ingredients = [[C, R1, D, B], [A, B]]
-Supplies = [A, B, C, D]
+Recipes = [C, D]
+Ingredients = [[A, B], [B, C]]
+Supplies = [A, B]
 ```
 
 For each recipe `recipes[i]`, we have the `ingredients[i]` that can make it, we take them as edges from ingredient to recipe:
 
 ```js
 // Graph (visualization)
-C, R1, D, B => R2
-A, B        => R1
+A, B => C
+B, C => D
 ```
 
 And we can use topological sort to find out what recipes can be made from our ingredients, supplies and even recipes we just have made it.
 
 So we build the graph from ingredients and count the indegrees for every recipes, and run BFS.
-```js
-// Graph (data structure)
-C: [R2]
-R1:[R2]
-D: [R2]
-B: [R2, R1]
-A: [R1]
-
-// Indegrees:
-R2: 4
-R1: 2
-```
 
-### Topological Sort (BFS)
+## Topological Sort (BFS)
 ```kotlin
 fun findAllRecipes(recipes: Array<String>, ingredients: List<List<String>>, supplies: Array<String>): List<String> {
     val graph = hashMapOf<String, HashSet<String>>()
@@ -85,68 +73,4 @@ fun findAllRecipes(recipes: Array<String>, ingredients: List<List<String>>, supp
 ```
 
 * **Time Complexity**: `O(R*I + S + R)` = `O(R*I + S)` where `R`, `I`, `S` represent the number of recipes, ingredients and supplies.
-* **Space Complexity**: `O(R*I + S)` for graph and queue.
-
-### ~~Brute Force~~
-```kotlin
-fun findAllRecipes(recipes: Array<String>, ingredients: List<List<String>>, supplies: Array<String>): List<String> {
-
-    val finishedRecipes = hashSetOf<String>()
-    val suppliesSet = hashSetOf<String>()
-    for (s in supplies) { suppliesSet.add(s) }
-
-    var recipeIndex = 0
-    while (recipeIndex < recipes.size) {
-        if (finishedRecipes.contains(recipes[recipeIndex])) {
-            recipeIndex++
-            continue
-        }
-        val ingredient = ingredients[recipeIndex]
-        var canMake = true
-        for (i in 0 until ingredient.size) {
-            if (!suppliesSet.contains(ingredient[i]) && !finishedRecipes.contains(ingredient[i])) {
-                canMake = false
-                break
-            }
-        }
-
-        if (canMake) {
-            finishedRecipes.add(recipes[recipeIndex])
-            recipeIndex = 0
-        } else {
-            recipeIndex++
-        }
-    }
-    return ArrayList<String>(finishedRecipes)
-}
-```
-
-* **Time Complexity**: `O(S + R^2 * I)`, where `R`, `I` and `S` represents the number of recipes, the max length in `ingredient[i]`, and the number of supplies.
-* **Space Complexity**: `O(R + S)`.
-
-
-```js
-// Recipes = [R2, R1]
-// Ingredients = [[C, R1, D, B], [A, B]]
-// Supplies = [A, B, C, D]
-
-// Graph (visualization)
-// C, R1, D, B => R2
-// A, B        => R1
-
-// Graph (data structure)
-C: [R2]
-R1:[R2]
-D: [R2]
-B: [R2, R1]
-A: [R1]
-
-// Indegrees:
-R2: 0
-R1: 0
-
-Queue: , , , , R2
-Current: R2
-
-Results: R1, R2
-```
+* **Space Complexity**: `O(R*I + S)` for graph and queue.