Add some solutions of new problems:

* 572. Subtree of Another Tree
* 35. Search Insert Position
* 143. Reorder List
* 1155. Number of Dice Rolls With Target Sum

Author: enginebai

leetcode/1155.number-of-dice-rolls-with-target-sum.md

@@ -0,0 +1,74 @@
+## [1155. Number of Dice Rolls With Target Sum](https://leetcode.com/problems/number-of-dice-rolls-with-target-sum/)
+
+```kotlin
+class Solution {
+
+    private val mod = 1000000000 + 7
+
+    fun numRollsToTarget(n: Int, k: Int, target: Int): Int {
+        // val memo = hashMapOf<Pair<Int, Int>, Int>()
+        // return topDownRecursion(n, k, target, memo)
+        return bottomUpDp1D(n, k, target)
+    }
+
+    private fun topDownRecursion(n: Int, k: Int, target: Int, memo: HashMap<Pair<Int, Int>, Int>): Int {
+        if (n == 1) {
+            if (target in 1..k) return 1
+            else return 0
+        }
+        
+        // Or 
+        // if (n == 0 && target == 0) return 1
+        // if (n == 0 || target == 0) return 0
+
+        if (memo.containsKey(n to target)) return memo[n to target]!!
+        var ways = 0
+        for (i in 1..k) {
+            if (target - i >= 0)
+                ways = (ways + topDownRecursion(n - 1, k, target - i, memo)) % mod 
+        }
+        memo[n to target] = ways 
+        return ways
+    }
+
+    private fun bottomUpDp(n: Int, k: Int, target: Int): Int {
+        // dp[i][t] represents i dice and target is t
+        val dp = Array(n + 1) { _ -> IntArray(target + 1) }
+        for (i in 0..n) {
+            for (t in 0..target) {
+                dp[i][t] = if (i == 0 && t == 0) 1
+                else if (i == 0 || t == 0) 0
+                else {
+                    var ways = 0
+                    for (j in 1..k) {
+                        if (t >= j)
+                            ways = (ways + dp[i - 1][t - j]) % mod
+                    }
+                    ways
+                }
+            }
+        }
+        return dp[n][target]
+    }
+
+    private fun bottomUpDp1D(n: Int, k: Int, target: Int): Int {
+        val dp = IntArray(target + 1)
+        for (i in 0..n) {
+            for (t in target downTo 0) {
+                dp[t] = if (i == 1) {
+                    if (t in 1..k) 1
+                    else 0
+                } else {
+                    var ways = 0
+                    for (j in 1..k) {
+                        if (t >= j)
+                            ways = (ways + dp[t - j]) % mod
+                    }
+                    ways
+                }
+            }
+        }
+        return dp[target]
+    }
+}
+```

leetcode/143.reorder-list.md

@@ -5,9 +5,28 @@ fun reorderList(head: ListNode?): Unit {
     if (head == null || head?.next == null) return
     val middle = middle(head)
     val reverseMiddleHead = reverse(middle)
-    merge(head, reverseMiddleHead)
+    
+    var node1: ListNode? = head
+    var node2: ListNode? = reversedHead
+
+    while (node1 != null && node2 != null) {
+        val next1 = node1.next
+        var next2 = node2.next
+
+        node1.next = node2
+        node2.next = next1
+
+        node1 = next1
+        node2 = next2
+    }
+
+    // Merge the remaining part
+    if (node2 != null) node1?.next = node2
 }
 
+// This function actually finds the next node of middle node.
+// 1 -> 2 -> 3 -> 4, returns 3
+// 1 -> 2 -> 3 -> 4 -> 5, returns 4
 private fun middle(head: ListNode?): ListNode? {
     var previous: ListNode? = null
     var slow: ListNode? = head
@@ -39,6 +58,7 @@ private fun reverse(head: ListNode?): ListNode? {
     return previous
 }
 
+// It works, but we have simpler way to merge.
 private fun merge(l1: ListNode?, l2: ListNode?) {
     var i = 2
     var result: ListNode? = l1

leetcode/235.lowest-common-acestor-of-a-binary-search-tree.md

@@ -46,4 +46,16 @@ fun lowestCommonAncestor(root: TreeNode?, p: TreeNode?, q: TreeNode?): TreeNode?
         else break
     }
     return node
-}
+}
+```
+
+### Recursive
+The same idea as *iterative once solution*.
+```kotlin
+fun lowestCommonAncestor(root: TreeNode?, p: TreeNode?, q: TreeNode?): TreeNode? {
+    if (root == null || p == null || q == null) return null
+    if (root.`val` < p.`val` && root.`val` < q.`val`) return lowestCommonAncestor(root.right, p, q)
+    if (root.`val` > p.`val` && root.`val` > q.`val`) return lowestCommonAncestor(root.left, p, q)
+    else return root
+}
+```

leetcode/33.search-in-rotated-sorted-array.md

@@ -2,7 +2,7 @@
 
 We have to solve with `O(lg n)` time complexity, so we will start from binary search, but we have to decide the left or right part to search for next round, and since the array might be rotated, it won't be sorted for both left and right part, we have modify some logic here:
 
-In each round of binary search, we will split the `array[start..end]` into two parts: `[start..middle - 1]` and  `[middle + 1..end]` and the key point here is that **one of the two parts will be sorted**, we have to find the sorted part (the starting value <= the ending value of that part) and we have to check if the target is in that sorted part, if yes, just search that part, otherwise, search another part.
+In each round of binary search, we will split the `array[start..end]` into two parts: `[start..middle - 1]` and  `[middle + 1..end]` and the key point here is that **there is always a half part will be sorted, either left or right part**, we have to find the sorted part (the starting value <= the ending value of that part) and we have to check if the target is in that sorted part, if yes, just search that part, otherwise, search another part.
 
 For example, nums = `[6, 7, 0, 1, 2, 5]`, target = 3:
 * The `middle` = 1, left part = `[6, 7, 0]`, right part = `[2, 5]`.
@@ -31,4 +31,6 @@ fun search(nums: IntArray, target: Int): Int {
     }
     return -1
 }
-```
+```
+
+Another way to implement the binary search

leetcode/35.search-insert-position.md

@@ -0,0 +1,22 @@
+## [35. Search Insert Position](https://leetcode.com/problems/search-insert-position/)
+
+```kotlin
+fun searchInsert(nums: IntArray, target: Int): Int {
+    var left = 0
+    var right = nums.size - 1
+    
+    if (target < nums[left]) return 0
+    else if (target > nums[right]) return nums.size
+
+    while (left <= right) {
+        val middle = left + (right - left) / 2
+        if (nums[middle] == target) return middle
+        if (nums[middle] < target) {
+            left = middle + 1
+        } else {
+            right = middle - 1
+        }
+    }
+    return left
+}
+```

leetcode/373.find-k-pairs-with-smallest-sums.md

@@ -29,14 +29,15 @@ fun kSmallestPairs(nums1: IntArray, nums2: IntArray, k: Int): List<List<Int>> {
         (nums1[p1.first] + nums2[p1.second]) - (nums1[p2.first] + nums2[p2.second])
     }
 
-    // We iterate all index in nums1 and use 0 as second index.
+    // We iterate all index in nums1 and use 0 as second index so that
+    // we don't have to trace the duplicate pair.
+    
     // We use at most k items for optimization
     for (i in 0 until nums1.size.coerceAtMost(k))) {
         minHeap.add(i to 0)
     }
 
     val results = mutableListOf<List<Int>>()
-    var i = 0
     // We iterate at most k times
     while (results.size() < k && !minHeap.isEmpty()) {
         val pair = minHeap.poll()

leetcode/572.subtree-of-another-tree.md

@@ -0,0 +1,17 @@
+## [572. Subtree of Another Tree](https://leetcode.com/problems/subtree-of-another-tree/)
+
+```kotlin
+fun isSubtree(root: TreeNode?, subRoot: TreeNode?): Boolean {
+    if (root == null && subRoot == null) return true
+    if (root == null || subRoot == null) return false
+
+    return isSameTree(root, subRoot) || isSubtree(root?.left, subRoot) || isSubtree(root?.right, subRoot)
+}
+
+private fun isSameTree(A: TreeNode?, B: TreeNode?): Boolean {
+    if (A == null && B == null) return true
+    if (A == null || B == null) return false
+
+    return A?.`val` == B?.`val` && isSameTree(A?.left, B?.left) && isSameTree(A?.right, B?.right)
+}
+```

leetcode/863.all-nodes-distance-k-in-binary-tree.md

@@ -57,61 +57,51 @@ class Solution {
 }
 ```
 
-### BFS
+### BFS (Level by Level)
 ```kotlin
-private val parents = hashMapOf<TreeNode, TreeNode>()
-private val results = mutableListOf<Int>()
-
 fun distanceK(root: TreeNode?, target: TreeNode?, k: Int): List<Int> {
+    val results = mutableListOf<Int>()
     if (root == null || target == null) return results
-    findParent(root, target)
-
-    var distance = 0
+    
+    val parentMap = updateParents(root!!, target!!)        
     val queue = ArrayDeque<TreeNode>()
     val visited = hashSetOf<TreeNode>()
-    queue.add(target)
-    visited.add(target)
-    while (queue.isNotEmpty() && distance <= k) {
+    queue.addLast(target)
+    var distances = 0
+    while (queue.isNotEmpty()) {
         val size = queue.size
         for (i in 0 until size) {
             val node = queue.removeFirst()
-            if (distance == k) {
+            if (visited.contains(node)) continue
+            visited.add(node)
+            if (distances == k) {
                 results.add(node.`val`)
             }
-            
-            if (node.left != null && !visited.contains(node.left)) {
-                queue.addLast(node.left)
-                visited.add(node.left)
-            }
-            if (node.right != null && !visited.contains(node.right)) {
-                queue.addLast(node.right)
-                visited.add(node.right)
-            }
-            if (parents.containsKey(node) && !visited.contains(parents[node]!!)) {
-                queue.addLast(parents[node]!!)
-                visited.add(parents[node]!!)
-            }
+            if (node.left != null && !visited.contains(node.left)) queue.addLast(node.left)
+            if (node.right != null && !visited.contains(node.right)) queue.addLast(node.right)
+            if (parentMap[node] != null && !visited.contains(parentMap[node]!!)) queue.addLast(parentMap[node]!!)
         }
-        distance++
+        distances++
+        if (distances > k) break
     }
     return results
 }
 
-private fun findParent(root: TreeNode?, target: TreeNode?) {
-    if (root == null) return
+private fun updateParents(root: TreeNode, target: TreeNode): HashMap<TreeNode, TreeNode> {
+    val parentMap = hashMapOf<TreeNode, TreeNode>()
     val queue = ArrayDeque<TreeNode>()
     queue.addLast(root)
-    while (queue.isNotEmpty() && !parents.containsKey(target)) {
+    while (queue.isNotEmpty() && !parentMap.containsKey(target)) {
         val node = queue.removeFirst()
-        
         if (node.left != null) {
-            parents[node.left] = node
+            parentMap[node.left] = node
             queue.addLast(node.left)
         }
         if (node.right != null) {
-            parents[node.right] = node
+            parentMap[node.right] = node
             queue.addLast(node.right)
         }
     }
+    return parentMap
 }
 ```

topics/dynamic-programming.md

@@ -539,10 +539,11 @@ longestCommonSubsequence(A, B, A.length, B.length)
 
 ### Top-Down DP
 ```kotlin
+// m, n represent the length of substring.
 fun longestCommonSubsequence(A: String, B: String, m: Int, n: Int, dp: Array<IntArray>): Int {
-    if (m < 0 || n < 0) return 0
+    if (m == 0 || n == 0) return 0
     if (dp[m][n] != -1) return dp[m][n]
-    dp[m][n] = if (A[m] == B[n]) 1 + longestCommonSubsequence(A, B, m - 1, n - 1, dp)
+    dp[m][n] = if (A[m - 1] == B[n - 1]) 1 + longestCommonSubsequence(A, B, m - 1, n - 1, dp)
     else max(
         longestCommonSubsequence(A, B, m - 1, n, dp),
         longestCommonSubsequence(A, B, m, n - 1, dp)

topics/problems-solutions.md

@@ -124,8 +124,8 @@
 |[863. All Nodes Distance K in Binary Tree](../leetcode/863.all-nodes-distance-k-in-binary-tree.md)|Medium|
 |[110. Balanced Binary Tree](../leetcode/110.balanced-binary-tree.md)|Easy|
 |[297. Serialize and Deserialize Binary Tree](../leetcode/297.serialize-and-deserialize-binary-tree.md)|Hard|
+|[572. Subtree of Another Tree](../leetcode/572.subtree-of-another-tree.md)|Easy|
 
-> * https://leetcode.com/problems/subtree-of-another-tree/ 5k e
 > * https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/ 6.1k m
 > * https://leetcode.com/problems/count-of-smaller-numbers-after-self/ 5k hard
 > * https://leetcode.com/problems/binary-tree-pruning/ 2k m
@@ -236,6 +236,7 @@
 |[279. Perfect Squares](../leetcode/279.perfect-squares.md)|Medium|
 |[322. Coin Change](../leetcode/322.coin-change.md)|Medium|
 |[518. Coin Change 2](../leetcode/518.coin-change-2.md)|Medium|
+|[1155. Number of Dice Rolls With Target Sum](../leetcode/1155.number-of-dice-rolls-with-target-sum.md)|Medium|
 
 > * https://leetcode.com/problems/combination-sum-iv/ 5k m
 > * https://leetcode.com/problems/minimum-cost-for-tickets/ 5k m
@@ -311,6 +312,7 @@
 |[704. Binary Search](../leetcode/704.binary-search.md)|Easy|
 |[33. Search in Rotated Sorted Array](../leetcode/33.search-in-rotated-sorted-array.md)|Medium|
 |[34. Find First and Last Position of Element in Sorted Array](../leetcode/34.find-first-and-last-position-of-element-in-sorted-array.md)|Medium|
+|[35. Search Insert Position](../leetcode/35.search-insert-position.md)|Easy}
 |[153. Find Minimum in Rotated Sorted Array](../leetcode/153.find-minimum-in-rotated-sorted-array.md)|Medium|
 |[74. Search a 2D Matrix](../leetcode/74.search-a-2d-matrix.md)|Medium|
 |[378. Kth Smallest Element in a Sorted Matrix](../leetcode/378.kth-smallest-element-in-a-sorted-matrix.md)|Medium|

topics/searching.md

@@ -24,8 +24,46 @@ fun binarySearch(A: IntArray, target: Int): Int {
 
 * **Time Complexity**: It takes `O(lg n)` time, it keeps searching the half size of subarray, that is, keeps divide `n` by 2 = `O(lg n)`.
 
+## Variants
+```kotlin
+fun binarySearch(A: IntArray, target: Int): Int {
+    var left = 0
+    var right = A.size - 1
+    while (left < right) {
+        val middle = left + (right - left) / 2
+        if (A[middle] < target) {
+            left = middle + 1
+        } else {
+            right = middle
+        }
+    }
+    return if (A[left] == target) left else -1
+}
+```
+
+> From [Binary Search 101](https://leetcode.com/problems/binary-search/solutions/423162/Binary-Search-101-The-Ultimate-Binary-Search-Handbook/)
+
+Some key points:
+
+* How to shrink the searching range by moving `left` and `right`? 
+```js
+if (100% sure logic) {
+    left = middle + 1
+} else {
+    right = middle
+}
+
+// or
+if (100% sure logic) {
+    right = middle - 1
+} else {
+    left = middle
+}
+```
+* Always use `while (left < right)`, so when while loop breaks, we will have `left == right`, and then check if the target exists or not. (might need further check, such as `if (A[left] == target)`).
+
 ## Resources
-- [ ] CTCI
-- [X] [Khan Academy](https://www.khanacademy.org/computing/computer-science/algorithms/binary-search/a/binary-search)
-- [X] [LC Learn - Binary Search](https://leetcode.com/explore/learn/card/binary-search/) // A very interesting and slightly different ways to implement different binary search algorithm.
-- [ ] [Google Recuriter Recommended Problems List](https://turingplanet.org/2020/09/18/leetcode_planning_list/#Binary_Search)
+- CTCI
+- [Khan Academy](https://www.khanacademy.org/computing/computer-science/algorithms/binary-search/a/binary-search)
+- [LC Learn - Binary Search](https://leetcode.com/explore/learn/card/binary-search/) // A very interesting and slightly different ways to implement different binary search algorithm.
+- [Google Recuriter Recommended Problems List](https://turingplanet.org/2020/09/18/leetcode_planning_list/#Binary_Search)