Update the explanation videos or references to problem listings

Author: enginebai

leetcode/112.path-sum.md

@@ -1,8 +1,5 @@
 # [112. Path Sum](https://leetcode.com/problems/path-sum/)
 
-## Clarification Questions
-* No, it's clear from problem description.
- 
 ## Test Cases
 ### Normal Cases
 ```
@@ -46,27 +43,15 @@ fun hasPathSum(root: TreeNode?, targetSum: Int): Boolean {
 
 private fun pathSum(root: TreeNode?, sum: Int, target: Int): Boolean {
     if (root == null) return false
-    if (root.left == null && root.right == null) {
-        return sum + root.`val` == target
-    }
-
-    return pathSum(root.left, sum + root.`val`, target) ||
-            pathSum(root.right, sum + root.`val`, target)
-}
-
-// root: The current node we are processing now
-// currentSum: The sum before processing the current node
-private fun dfs(root: TreeNode?, sum: Int) {
-    if (root == null) return
-
     // Process current node
     val currentSum = sum + root.`val`
 
-    // Do something with the current node
+    if (root.left == null && root.right == null) {
+        return curretnSum == target
+    }
 
-    // Child nodes
-    dfs(root.left, currentSum)
-    dfs(root.right, currentSum)
+    return pathSum(root.left, currentSum, target) ||
+            pathSum(root.right, currentSum, target)
 }
 ```
 

leetcode/1339.maximum-product-of-splitted-binary-tree.md

@@ -3,44 +3,44 @@
 ## Postorder
 For a root node, how can we split into two subtrees to get the product of the sums of the subtrees?
 ```js
-    2     
-   / \    
-  3   4
+     10     
+    /  \    
+   3    4
 
 // Can split into two cases
-     2             2
-      \     or    /
-   3   4         3   4
-
- = 3 * 6    or   5 * 4
+     10             10
+       \     or    /
+   X    4         3    X
+ 
+ = 3 * 14    or   13 * 4
 ```
-If we split the left child, for example, then the product will be `3 * (2 + 4)`, which is `the sum of the left subtree` x `total sum - the left subtree`. (The same for the right child)
+If we split the left child, for example, then the product will be `3 * (10 + 4)`, which is `the sum of the left subtree` x `total sum - the left subtree`. (The same for the right child)
 
 So for any root node, we can calculate the left subtree sum and the right subtree sum, and then
 * Split left = `sum(left) * (total sum - sum(left))`
 ```js
-        root
+         root
                \
 sum(left)    sum(right)
 ```
 * Split right = `(total sum - sum(right)) * sum(right)`
 ```js
-        root
+         root
      /
 sum(left)    sum(right)
 ```
 
-We can use postorder to calculate the sum of the subtree and the total sum of the tree. Then we can calculate the product of the splitted tree for each node and update the maximum product.
+We compute the total sum of the tree first, then use postorder to compute subtree sums and update the maximum product while computing the sum of the tree.
 
 ```kotlin
-private val mod = 1000000000L + 7
-private var result = 0L
+private val mod = 10_000_000_007
+private var maxProduct = 0L
 private var total = 0L
 
 fun maxProduct(root: TreeNode?): Int {
     total = sum(root)
     sum(root)
-    return (result % mod).toInt()
+    return (maxProduct % mod).toInt()
 }
 
 private fun sum(root: TreeNode?): Long {
@@ -54,37 +54,34 @@ private fun sum(root: TreeNode?): Long {
 
     val leftSplit = left * (total - left)       // 2 * (10 - 2)
     val rightSplit = (total - right) * right    // (10 - 3) * 3
-    result = maxOf(result, maxOf(leftSplit, rightSplit))
+    maxProduct = maxOf(maxProduct, maxOf(leftSplit, rightSplit))
 
-    return root.`val`.toLong()+ left + right
+    return root.`val`.toLong() + left + right
 }
 ```
 
 Or the same idea, we can split at root node:
 ```js
  parent
     \
-     X  // split here
+     X  // split here when calculating the sum of `root`
       \
        root     sum(root)
       /    \
     left  right
+```
 
 ```kotlin
-private val mod = 1000000000L + 7
-private var result = 0L
-private var total = 0L
-
 fun maxProduct(root: TreeNode?): Int {
     total = sum(root)
     sum(root)
-    return (result % mod).toInt()
+    return (maxProduct % mod).toInt()
 }
 
 private fun sum(root: TreeNode?): Long {
     if (root == null) return 0L
     val currentSum = root.`val` + sum(root.left) + sum(root.right)
-    result = maxOf(result, currentSum * (total - currentSum))
+    maxProduct = maxOf(maxProduct, currentSum * (total - currentSum))
     return currentSum
 }
 ```

leetcode/1552.magnetic-force-between-two-balls.md

@@ -11,7 +11,7 @@ positions: a, _, _, d, _, _, _, e, _ f
                                 |----|  // The minimum distance
 ```
 
-We have a fixed search range, next, we'd like to discover the monotonicity characteristic to apply binary search:
+We have a fixed search space, next, we'd like to discover the monotonicity characteristic to apply binary search:
 
 **As the distance increases, the number of balls we can place decreases. (we have to put `m` balls)**
 * If we can place all the balls with a minimum distance `d` (other distances might be larger than `d`, it's acceptable), then we can also place all the balls with a shorter distance `d2` where `d2 < d`. For example, we can put 3 balls with the distance `4`, then we can also put 3 balls with the distance `3`, `2`, `1`.

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

@@ -44,7 +44,7 @@ quantities = [1]
 [1],[0], ... , [0], ... ,[0]
 ```
 
-This forms a **fixed search range** for the answer, `[1, max(quantities)]`:
+This forms a **fixed search space** for the answer, `[1, max(quantities)]`:
 * Lower bound is `1`, we must distribute at least one product to stores. (Some stores may get `0` products if there is not enough products to distribute)
 * Upper bound is the `max(quantities)`, because we can distribute all products of single type to one store.
 

leetcode/410.split-array-largest-sum.md

@@ -17,7 +17,7 @@ We try to minimize the largest sum amoung `k` subarrays:
 * Upper bound is `sum(nums)`, because we can split the array into `k == 1` subarray (only one split) which is `[7 + 2 + 5 + 10 + 8]` = `32`.
 The possible answer must be in the range `[max(nums), sum(nums)]`.
 
-Since we have a fixed search range, then we have to discover the monotonicity characteristic to apply binary search: 
+Since we have a fixed search space, then we have to discover the monotonicity characteristic to apply binary search: 
 * Given a largest sum `ans` (answer), if we can split the array into `k` groups, then we also can split the array with larger value `ans + 1`, `ans + 2`, etc. Because there are more numbers formed one split with the larger value, the total split count will become less, which also satisfy the condition: `splitCount <= k`. (Why `splitCount < k` is also acceptable? See below)
 * If the largest sum is too small that we can't split the array into `k` groups (more than `k` splits), then we also can't split the array with smaller largest sum since smaller value will have more splits.
 

leetcode/563.binary-tree-tilt.md

@@ -1,7 +1,11 @@
 # [563. Binary Tree Tilt](https://leetcode.com/problems/binary-tree-tilt/description/)
 
+## Breakdowns
+* The tilt of a node is `abs(sum(left) - sum(right))`.
+* The answer is the tilt of the whole tree, which is the sum of the tilt of all nodes.
+
 ## Top-Down Approach (Double Recursion)
-For each node, we have to calculate the left and right sum to calculate current tilt. Then we calculate the tilt of left and right child. The tilt of left and right child is the same problem, so we can use recursion to solve it.
+For each node, we have to calculate the left and right sum to calculate current tilt. Then we calculate the sum of the tilt of current + left + right.
 
 ```kotlin
 fun findTilt(root: TreeNode?): Int {
@@ -26,7 +30,7 @@ private fun sum(root: TreeNode?): Int {
 * **Space Complexity:** `O(n)`
 
 ## Bottom-Up Approach (Single Recursion)
-We can update the global result during calculating the sum of the tree. We can return the sum of the current root and update the global result.
+We can optimize the top-down approach by calculating the sum of the tree and tilt at the same time in bottom-up approach. At each node, we return the sum of the tree to its parent, and maintain a global variable to track the tilt sum.
 
 ```kotlin
 private var tiltSum = 0
@@ -48,5 +52,25 @@ private fun sum(root: TreeNode?): Int {
 }
 ```
 
+Or equivalently, we return sum of tilt and sum of the tree in a pair.
+
+```kotlin
+fun findTilt(root: TreeNode?): Int {
+        return sum(root).first
+    }
+
+// return <sum of tilt, sum of subtree>
+private fun sum(root: TreeNode?): Pair<Int, Int> {
+    if (root == null) return 0 to 0
+    val left = sum(root.left)
+    val right = sum(root.right)
+
+    val tilt = abs(left.second - right.second)
+    val nodeSum = root.`val` + left.second + right.second
+    val tiltSum = tilt + left.first + right.first
+    return tiltSum to nodeSum
+}
+```
+
 * **Time Complexity:** `O(n)`
 * **Space Complexity:** `O(n)`

leetcode/671.second-minimum-node-in-a-binary-tree.md

@@ -1,11 +1,6 @@
 # [671. Second Minimum Node In a Binary Tree](https://leetcode.com/problems/second-minimum-node-in-a-binary-tree/description/)
 
-# Test Cases
-### Normal Cases
-```
-Input: 
-Output: 
-```
+## Test Cases
 ### Edge / Corner Cases
 * All the values are the same.
 ```
@@ -30,40 +25,92 @@ Output: 2
 ```
 
 ## DFS
+We can traverse the tree and find the second minimum value directly.
+
+```kotlin
+private var min1 = Long.MAX_VALUE
+private var min2 = Long.MAX_VALUE
+
+fun findSecondMinimumValue(root: TreeNode?): Int {
+    dfs(root)
+    return if (min2 == Long.MAX_VALUE) -1 else min2.toInt()
+}
+
+private fun dfs(root: TreeNode?) {
+    if (root == null) return
+    val value = root.`val`.toLong()
+    if (value < min1) {
+        min2 = min1
+        min1 = value
+    } else if (min1 < value && value < min2) {
+        min2 = value
+    }
+    dfs(root.left)
+    dfs(root.right)
+}
+```
+
+The straightforward solution is not using the special property of the tree. We can optimize the solution by using the property of the tree.
+
 Based on the special property of the tree:
 * The top-level root is the first minimum value.
 * The value of root node <= the value of its children nodes.
 
-We find the value that is greater than the top-level root value but smaller than any existing value.
+We find the value that is **greater than the top-level root value but minimum value among nodes**.
 
 > 我们只需要通过遍历，找出严格大于 rootvalue 的最小值，即为「所有节点中的第二小的值」。
 
 ```kotlin;
-private var firstMin = Long.MAX_VALUE
-private var secondMin = Long.MAX_VALUE
+private var min1 = Long.MAX_VALUE
+private var min2 = Long.MAX_VALUE
 
 fun findSecondMinimumValue(root: TreeNode?): Int {
     if (root == null) return -1
     // The top-level root is the first minimum value.
-    firstMin = root.`val`.toLong()
+    min1 = root.`val`.toLong()
     dfs(root)
-    return if (secondMin == Long.MAX_VALUE) -1 else secondMin.toInt()
+    return if (min2 == Long.MAX_VALUE) -1 else min2.toInt()
 }
 
+// Find the mimimum value that is greater than the root value. (not the 2nd minimum value)
 private fun dfs(root: TreeNode?) {
     if (root == null) return
     val rootValue = root.`val`.toLong()
-    // root value <= children values, so we don't need to check the children values.
-    if (secondMin < rootValue) return
+    // (Optional) if root value <= children values, so we don't need to check the children values.
+    // The children are impossible to be the minimum value.
+    if (min2 <= rootValue) return
 
-    // Update the second minimum value.
-    if (firstMin < rootValue && rootValue < secondMin) {
-        secondMin = rootValue
+    // If it's the minimum value that is greater than the root value.
+    if (min1 < rootValue && rootValue < min2) {
+        min2 = rootValue
     }
     dfs(root.left)
     dfs(root.right)
 }
 ```
 
+Or equivalently, we can return the minimum value that is greater than the root value from `dfs()` function:
+```kotlin
+fun findSecondMinimumValue(root: TreeNode?): Int {
+    if (root == null) return -1
+    val min2 = dfs(root, root.`val`.toLong())
+    return if (min2 == Long.MAX_VALUE) -1 else min2.toInt()
+}
+
+private fun dfs(root: TreeNode?, min1: Long): Long {
+    if (root == null) return Long.MAX_VALUE
+
+    val rootValue = root.`val`.toLong()
+    if (min1 < rootValue) {
+        return rootValue
+    }
+    val left = dfs(root.left, min1)
+    val right = dfs(root.right, min1)
+    if (left == Long.MAX_VALUE) return right
+    if (right == Long.MAX_VALUE) return left
+    return minOf(left, right)
+}
+```
+
 * **Time Complexity:** `O(n)`
 * **Space Complexity:** `O(h)`

leetcode/875.koko-eating-bananas.md

@@ -5,19 +5,6 @@
 * `h` range?
 * What is the range of `piles[i]`? Will it be negative?
 
-## Test Cases
-### Normal Cases
-```
-Input: 
-Output: 
-```
-### Edge / Corner Cases
-* 
-```
-Input: 
-Output: 
-```
-
 ## Linear Search
 We're finding the speed slow enough and can eat all within `n` hours. Let's start from eating 1 banana per hour, and check if it's possible to eat all piles within `h` hours. If not, we increase the speed by 1 and check again.
 
@@ -33,6 +20,8 @@ fun minEatingSpeed(piles: IntArray, h: Int): Int {
 
 ## Binary Search
 We can optimize the linear search solution with some modifications based on some key observations:
+
+### Search Space
 1. Every time Koko eats at least one banana, so the minimum speed is 1.
 2. The maximum speed is the maximum of piles because Koko chooses only one pile to eat at a time.
 3. As the eating speed is slower, the required hours is longer, and vice versa. And if we can find the minimum speed to eat all, then any higher speed would be eat all as well. And if we can't find the minimum speed to eat all, then any lower speed would be impossible to eat all. This exhibits the **monotonicity** characteristic, so we can use binary search to find the minimum speed: **We're looking for the first (minimal) speed that satisfies the condition: `canEatAll(piles, middle, h)`**.

problems/binary-search-problems.md

@@ -93,4 +93,25 @@
 > * https://leetcode.com/problems/search-in-rotated-sorted-array-ii/ 8k m
 > * https://leetcode.com/problems/peak-index-in-a-mountain-array/description/ m
 > * https://leetcode.com/problems/kth-missing-positive-number/description/ e
-> * **https://leetcode.com/problems/median-of-two-sorted-arrays/description/**
+> * **https://leetcode.com/problems/median-of-two-sorted-arrays/description/**
+
+## Explanation
+* [34. Find First and Last Position of Element in Sorted Array](https://www.youtube.com/watch?v=sX5IbSSNKXI)
+* [475. Heaters](https://www.youtube.com/watch?v=25LSSsAGLDw)
+* [875. Koko Eating Bananas](https://www.youtube.com/watch?v=yfWVWbi9pts)
+* [1011. Capacity To Ship Packages Within D Days](https://www.youtube.com/watch?v=-F2ysRiSTvk)
+* [1482. Minimum Number of Days to Make m Bouquets](https://www.youtube.com/watch?v=D_Pq9SqEwsc)
+* [1631. Path With Minimum Effort](https://www.youtube.com/watch?v=vIJ8ue4pQtw)
+* [2560. House Robber IV](https://www.youtube.com/watch?v=_-nBUCSeU98)
+* [2226. Maximum Candies Allocated to K Children](https://www.youtube.com/watch?v=TBTvnyMLgng)
+* [410. Split Array Largest Sum](https://www.youtube.com/watch?v=PBvgA3sV5Zs)
+* [2064. Minimized Maximum of Products Distributed to Any Store](https://www.youtube.com/watch?v=0Lyu_B_Ao7k)
+* [1552. Magnetic Force Between Two Balls](https://www.youtube.com/watch?v=6oSU44kkV-U)
+* [240. Search a 2D Matrix II](https://www.youtube.com/watch?v=-IzCjqVsjZw)
+* [378. Kth Smallest Element in a Sorted Matrix](https://www.youtube.com/watch?v=JJUv4DDLSB4)
+* [729. My Calendar I](https://www.youtube.com/watch?v=g30lRE3ASiA)
+* [1146. Snapshot Array](https://github.com/wisdompeak/LeetCode/tree/master/Design/1146.Snapshot-Array)
+* [162. Find Peak Element](https://www.youtube.com/watch?v=esY2RWhmZ74)
+* [287. Find the Duplicate Number](https://www.youtube.com/watch?v=86co28GuZ5U)
+* [33. Search in Rotated Sorted Array](https://github.com/wisdompeak/LeetCode/tree/master/Binary_Search/033.Search-in-Rotated-Sorted-Array)
+* [153. Find Minimum in Rotated Sorted Array](https://github.com/wisdompeak/LeetCode/tree/master/Binary_Search/153.Find-Minimum-in-Rotated-Sorted-Array)