Update some notes of tree and graph problems

Author: enginebai

leetcode/1022.sum-of-root-to-leaf-binary-numbers.md

@@ -1,4 +1,4 @@
-## [1022. Sum of Root To Leaf Binary Numbers](https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers/)
+# [1022. Sum of Root To Leaf Binary Numbers](https://leetcode.com/problems/sum-of-root-to-leaf-binary-numbers/)
 ## Clarification Questions
 * No, it's clear from problem description.
 
@@ -14,6 +14,42 @@ Output:
 Input: 
 Output: 
 ```
+
+## Paths
+We can get all paths from root to leaf, and then calculate the sum of binary numbers.
+```kotlin
+private val paths = mutableListOf<List<Int>>()
+
+fun sumRootToLeaf(root: TreeNode?): Int {
+    dfs(root, LinkedList<Int>())
+    var answer = 0
+    for (path in paths) {
+        var sum = 0
+        for (i in 0 until path.size) {
+            // 1, 1, 0, 1
+            //       <- i
+            sum += path[path.size - 1 - i] * Math.pow(2.0, i.toDouble()).toInt()
+        }
+        answer += sum
+    }
+    return answer
+}
+
+private fun dfs(root: TreeNode?, path: LinkedList<Int>) {
+    if (root == null) return
+
+    path.addLast(root.`val`)
+    if (root.left == null && root.right == null) {
+        paths.add(ArrayList(path))
+    }
+
+    dfs(root.left, path)
+    dfs(root.right, path)
+    path.removeLast()
+}
+```
+
+## Recursive
 ```kotlin
 private var sum = 0
 

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

@@ -101,13 +101,18 @@ private fun preorder(root: TreeNode?, list: MutableList<TreeNode>) {
 * **Space Complexity**: `O(n)`.
 
 ## Preorder + Relink
-Use the template of preorder iterative traversal, and for every node, we have some extra steps:
+Use the template of preorder iterative traversal, and for every node, we relink the current node:
 1. We relink the right subtree after the right most node of left child.
 2. Move left child to right child.
 3. Clear left child.
 4. Go to next node.
 
+![](../media/114.preorder+relink-1.png)
+![](../media/114.preorder+relink-2.png)
+![](../media/114.preorder+relink-3.png)
+
 ```kotlin
+// Follow the template of preorder traversal.
 fun flatten(root: TreeNode?): Unit {
     if (root == null) return
     val stack = Stack<TreeNode>()
@@ -119,12 +124,15 @@ fun flatten(root: TreeNode?): Unit {
 
         if (right != null) stack.push(right)
         if (left != null) {
-            // Start of extra steps
-            val rightMost = subtreeLast(left)
-            rightMost.right = right
+            // Start of relink
+            val rightMost: TreeNode? = left
+            while (rightMost?.right != null) {
+                rightMost = rightMost.right
+            }
+            rightMost?.right = right
             node.right = left
             node.left = null
-            // End of extra steps
+            // End of relink
 
             stack.push(left)
         }
@@ -202,6 +210,7 @@ private fun subtreeLast(root: TreeNode?): TreeNode? {
 }
 ```
 
+### Dry Run (Postorder with Pointers)
 ```kotlin
         1
      /     \

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

@@ -23,6 +23,7 @@ Output:
 ### Edge / Corner Cases
 * Empty or single node tree
 
+## BFS
 ```kotlin
 fun connect(root: Node?): Node? {
     if (root == null) return null
@@ -44,7 +45,32 @@ fun connect(root: Node?): Node? {
 * **Time Complexity**: `O(n)`.
 * **Space Complexity**: `O(n)`.
 
-### Space Optimal
+
+## Recursive
+```kotlin
+/**
+ *        1
+ *     /     \
+ *    2       3
+ *   / \     / \
+ *  4   5   6   7
+ */
+fun connect(root: Node?): Node? { // connect(1)
+    if (root == null) return null
+    dfs(root.left, root.right) // dfs(2, 3)
+    return root
+}
+
+fun dfs(left: Node?, right: Node?) { // dfs(2, 3)
+    if (left == null || right == null) return
+    left.next = right
+    dfs(left.left, left.right)      // 4 -> 5
+    dfs(left.right, right.left)     // 5 -> 6
+    dfs(right.left, right.right)    // 6 -> 7
+}
+```
+
+## Space Optimal
 > TODO: `O(1)` space complexity.
 
 > Take a look at another solution (using the `next` pointer just built): https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/solution/tian-chong-mei-ge-jie-dian-de-xia-yi-ge-you-ce-2-4/

leetcode/1325.delete-leaves-with-a-given-value.md

@@ -59,7 +59,7 @@ Output: []
 ```
 
 ## Recursive
-**Idea!!** Postorder, for problem statement `Note that once you delete a leaf node with value target, if its parent node becomes a leaf node and has the value target, it should also be deleted`, so we have to process the child first, when we've done, we check the root to see if that becomes the leaf and if to delete or not.
+For problem statement `Note that once you delete a leaf node with value target, if its parent node becomes a leaf node and has the value target, it should also be deleted`, so we have to process the children first, then we should use postorder traversal, as we finish traversing the children, we check the root to see if that becomes the leaf and if to delete or not.
 
 ```kotlin
 fun removeLeafNodes(root: TreeNode?, target: Int): TreeNode? {

leetcode/230.kth-smallest-element-in-a-bst.md

@@ -26,6 +26,7 @@ Output:
 * The inorder traversal of BST is in the ascending order, so we can traverse the BST in inorder and increment the index until it reaches `k`.
 
 ```kotlin
+// Iterative
 fun kthSmallest(root: TreeNode?, k: Int): Int {
     if (root == null) -1
     val stack = Stack<TreeNode>()
@@ -43,6 +44,26 @@ fun kthSmallest(root: TreeNode?, k: Int): Int {
     }
     return -1
 }
+
+// Recursive
+private var i = 0
+private var result = -1
+
+fun kthSmallest(root: TreeNode?, k: Int): Int {
+    inorder(root, k)
+    return result
+}
+
+private fun inorder(root: TreeNode?, k: Int) {
+    if (root == null) return
+    inorder(root.left, k)
+    i++
+    if (i == k) {
+        result = root.`val`
+        return
+    }
+    inorder(root.right, k)
+}
 ```
 
 * **Time Complexity**: `O(h + k)`, `h` for stack and k-th elements.
@@ -76,17 +97,29 @@ private fun count(root: TreeNode?): Int {
 }
 ```
 
-* **Time Complexity**: `O(h)`.
+* **Time Complexity**: `O(n^2)` if we don't precompute the count, or `O(n)` if we precompute and preserve the count of nodes in each node.
 * **Space Complexity**: `O(h)`.
 
-> Why do we search for `k - leftCount - 1`-th element in the right subtree?
+Why do we search for `k - leftCount - 1`-th element in the right subtree?
 ```js
-k = 7
-        5         leftCount(5) = 4 < 7 - 1, so we search in right subtree.
-     /     \           
-    3       8     kthSmallest(8, 7 - 4 - 1 = 2), we search the 2nd smallest in the subtree 8.
-   / \     / 
-  1  4    6
-   \       \
-    2       7
+k = 5
+leftCount(5) = 4
+
+         5    // start from 5 to search 5th smallest element
+       /   \
+      3     7
+     / \   / \
+    2  4  6   8
+   /
+  1
+
+k = 6
+
+         5      // start from 5 to search 6th smallest element
+       /   \
+      3     7   // start from 7 to search 6 - 4 - 1 = 1th smallest element
+     / \   / \
+    2  4  6   8
+   /
+  1
 ```