Update tree problem notes

Author: enginebai

leetcode/1110.delete-nodes-and-return-forest.md

@@ -43,38 +43,59 @@ Output:
          /   / 
         2   6  
 ```
+* The root is deleted.
+* All the nodes are deleted.
+* All the nodes in subtrees are deleted.
+
+## Breakdown
+> Given the values to delete, how to delete the nodes (prune all the subtrees) and return the root?
+```kotlin
+fun del(root: TreeNode?, toDelete: Set<Int>): TreeNode? {
+	if (root == null) return null
+	if (root.`val` in toDelete) {
+		return null
+	}
+	root.left = del(root.left, toDelete)
+	root.right = del(root.right, toDelete)
+	return root
+}
+```
 
 ## Postorder 
-**Idea!!** We can traverse the tree, if the current node is in the delete list, we can add its children to the forest.
+**Idea!!** We traverse each node as root, and check if we should delete the root. If we should delete the root, we add the children to the forest. But bfore that, we need to check all the children first.
 
 ```js
-        1       del(1)
-     /     \
-    2       3
+      root       del(root)
+     /    \
+  left   right
   ...       ...
 
-// After delete `1`, the subtrees `2` and `3` become the forest.
-     /     \
-    2       3
+// After delete `root`, the subtrees `left` and `right` become the forest.
+     /    \
+  left   right
   ...       ...
 ```
-We use postorder to delete, because we need to delete the nodes from the bottom to the top. Here is one key point to note, if the original root is not in the delete list, we should add it to the forest first.
+We use postorder to delete, because we need to delete the nodes from the bottom to the top.
+
+Here is one key point to note, if the original root is not in the delete list, we should add it to the forest first.
 ```kotlin
 fun delNodes(root: TreeNode?, to_delete: IntArray): List<TreeNode?> {
-    val set = HashSet<Int>()
-    for (d in to_delete) set.add(d)
+    val set = to_delete.toHashSet()
     val forest = mutableListOf<TreeNode?>()
-    // If the root is not in the delete list, add it to the forest first.
-    if (!set.contains(root?.`val`)) forest.add(root)
-    delete(root, set, forest)
+    val updatedRoot = delete(root, set, forest)
+    // If the root is not deleted, we should add it to the forest. Otherwise, the root won't be added to the forest.
+    if (updatedRoot != null) forest.add(updatedRoot)
     return forest
 }
 
 private fun delete(root: TreeNode?, deleteSet: HashSet<Int>, forest: MutableList<TreeNode?>): TreeNode? {
     if (root == null) return null
 
+	// We delete the child nodes first.
     root.left = delete(root.left, deleteSet, forest)
     root.right = delete(root.right, deleteSet, forest)
+
+	// Then check if we should delete the current root, then all children become the forest.
     if (deleteSet.contains(root.`val`)) {
         if (root.left != null) forest.add(root.left)
         if (root.right != null) forest.add(root.right)

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

@@ -72,7 +72,7 @@ Output:
         3
 ```
 
-## Preorder
+## Iterate and Relink
 We traverse the tree in preoder and store the nodes in a list. Then we relink the nodes in the list.
 ```kotlin
 fun flatten(root: TreeNode?): Unit {
@@ -101,7 +101,7 @@ 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 relink the current node:
+We do a preorder 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.
@@ -169,6 +169,9 @@ fun flatten(root: TreeNode?): Unit {
         // Because we have relinked the left child to right child above: `current.right = left`
         // This move can ensure we travese all possible (original) left child first then right child.
         current = current.right
+
+        // This is wrong, because right is relinked to left child, we should move to the new right child.
+        // current = right 
     }
 }
 

leetcode/129.sum-root-to-leaf-numbers.md

@@ -27,9 +27,9 @@ Output: 235 + 2371 + 24 = 2630
 ## DFS
 For `2 -> 3 -> 5`, we traverse to build the number `235`: 
 * Start from `0`.
-* At `2`, the number will become `0 * 10 + 2` -> `2`.
-* At `3`, the number will become `2 * 10 + 3` -> `23`.
-* At `5`, the number will become `23 * 10 + 5` -> `235`. And it's a leaf node, so we sum it.
+* At `2`, the number will become `0 * 10 + 2` -> `2`, then we go down to child node with `2`.
+* At `3`, the number will become `2 * 10 + 3` -> `23`, then we go down to child node with `23`.
+* At `5`, the number will become `23 * 10 + 5` -> `235`. And it's a leaf node, so we return `235`.
 
 ![](https://assets.leetcode-cn.com/solution-static/129/fig1.png)
 > Source: https://leetcode.cn/problems/sum-root-to-leaf-numbers/solutions/464666/qiu-gen-dao-xie-zi-jie-dian-shu-zi-zhi-he-by-leetc/

leetcode/1367.linked-list-in-binary-tree.md

@@ -1,58 +1,133 @@
 # [1367. Linked List in Binary Tree](https://leetcode.com/problems/linked-list-in-binary-tree/description/)
 
-## Clarification Questions
-* No, it's clear from problem description.
- 
 ## Test Cases
-### Normal Cases
-```
-Input: 
-Output: 
-```
 ### Edge / Corner Cases
 * The linked list or tree is empty.
 * The linked list is longer than the tree.
+```
 list: 1 -> 2 -> 3
 tree: 
-```
     1
    / \
   2   3
 ```
 
 * The linked list is shorter than the tree.
+```
 list: 1
 tree: 
-```
     1
    / \
   2   3
 ```
 
+* Tree is the subsequence of the linked list.
+```
+list: 5 -> 8
+tree: 
+    5
+   / 
+  2  
+ / 
+8
+```
+
 # Approach
-It's similar to [572. Subtree of Another Tree](https://leetcode.com/problems/subtree-of-another-tree/), but we need to check if the linked list is a "substring" of the tree, not a subtree. (All the node in linked list have to be in the tree, but not all tree nodes have to be in the linked list.)
+It's similar to [572. Subtree of Another Tree](../leetcode/572.subtree-of-another-tree.md), but we need to check if the linked list is a "substring" of the tree, not a subtree. (All the node in linked list have to be in the tree, but not all tree nodes have to be in the linked list.)
 
 ```kotlin
 fun isSubPath(head: ListNode?, root: TreeNode?): Boolean {
-    // Slight different between `contains()`, we have to decide base on the definition of this recursive function.
-    if (head == null && root == null) return true   // Both are empty, is a subpath.
-    if (head == null || root == null) return false  // One of them is empty, is not a subpath.
-
+    if (root == null) return false
+    
     // Search the linked list starting from the root node.
     return contains(head, root) ||
         isSubPath(head, root.left) || isSubPath(head, root.right) // Or search the linked list in the left and right subtree.
 }
 
 private fun contains(head: ListNode?, root: TreeNode?): Boolean {
+    if (head == null && root == null) return true
     // Tree contains empty list or we reach the end of the list, then it's a subpath.
-    if (head == null) return true
+    if (head == null && root != null) return true
     // It means we have reached the end of the tree, but the linked list is not found.
-    if (root == null) return false
+    if (head != null && root == null) return false
 
     // Keep searching the linked list in the tree.
     return head.`val` == root.`val` && (contains(head.next, root.left) || contains(head.next, root.right))
 }
 ```
 
 * **Time Complexity:** `O(N * M)`, where `N` is the number of nodes in the tree and `M` is the number of nodes in the linked list.
-* **Space Complexity:** `O(N + M)`, we have to travesal the tree `O(N)` and we check `contain()` which takes `O(M)` space in each tree node.
+* **Space Complexity:** `O(N + M)`, we have to travesal the tree `O(N)` and we check `contain()` which takes `O(M)` space in each tree node.
+
+
+## WA
+```js
+head = 1 -> 8
+root =
+     1
+    /
+   6
+  /
+ 8
+```
+```kotlin
+fun isSubPath(head: ListNode?, root: TreeNode?): Boolean {
+    if (head == null && root == null) return true
+    if (head == null && root != null) return true
+    if (head != null && root == null) return false
+
+    val h = head!!
+    val r = root!!
+    val result1 = 
+        h.`val` == r.`val` && (
+        isSubPath(h.next, r.left) ||
+        isSubPath(h.next, r.right))
+
+    val result2 = 
+        isSubPath(h, r.left) ||
+        isSubPath(h, r.right)
+
+    return result1 || result2
+}
+```
+
+* `result1` represents the case that the linked list starts from the current node in the tree. And keep searching if all the nodes in the linked list are in the tree. It's **a continuation of the previous search**.
+* `result2` represents the case that we search the beginning of the linked list in the left and right subtree of the current node. It's **a new search**, not a continuation of the previous search.
+
+The problem here is that `isSubPath()` will check current `root` and **also start a new search** in the left and right subtree. But we should not start a new search in `result1`, it should be a continuation of the previous search. We should create a new function to handle the continuation of the previous search.
+
+Corrected version:
+```kotlin
+fun isSubPath(head: ListNode?, root: TreeNode?): Boolean {
+    if (head == null && root == null) return true
+    if (head == null && root != null) return true
+    if (head != null && root == null) return false
+
+    val h = head!!
+    val r = root!!
+    // Check the current and continue the search from the previous search.
+    val result1 = 
+        h.`val` == r.`val` && (
+        search(h.next, r.left) ||   // Modified
+        search(h.next, r.right))    // Modified
+
+    // Start a new search in the left and right subtree.
+    val result2 = 
+        isSubPath(h, r.left) ||
+        isSubPath(h, r.right)
+    
+    return result1 || result2
+}
+
+// It's a continuation of the previous search.
+private fun search(head: ListNode?, root: TreeNode?): Boolean {
+    // Same as above.
+    if (head == null && root == null) return true
+    if (head == null && root != null) return true
+    if (head != null && root == null) return false
+
+    val h = head!!
+    val r = root!!
+    return h.`val` == r.`val` && (search(head.next, root.left) || search(head.next, root.right))
+}
+```

leetcode/1372.longest-zigzag-path-in-a-binary-tree.md

@@ -1,5 +1,15 @@
 # [1372. Longest ZigZag Path in a Binary Tree](https://leetcode.com/problems/longest-zigzag-path-in-a-binary-tree/)
 
+## Breakdowns
+> 1. How to find the longest leftward or rightward path in a tree?
+
+```kotlin
+private fun dfs(root: TreeNode?): Int {
+    if (root == null) return 0
+    return if (root.left != null) 1 + dfs(root.left) else 0
+}
+```
+
 ## Double Recursion
 ```js
 // Previous direction is right,
@@ -15,11 +25,13 @@ left    \
 ```
 
 ```kotlin
+private val left = 1
+private val right = -1
 private var longestPath = 0
 fun longestZigZag(root: TreeNode?): Int {
     if (root == null) return 0
-    dfs(root.left, 0, 0)
-    dfs(root.right, 1, 0)
+    dfs(root.left, left, 0)
+    dfs(root.right, right, 0)
     return longestPath
 }
 
@@ -32,16 +44,16 @@ private fun dfs(root: TreeNode?, previousDirection: Int, steps: Int) {
     longestPath = maxOf(longestPath, steps + 1)
 
     // Previously go left, then it should go right
-    if (previousDirection == 0) {
-        dfs(root.right, 1, steps + 1)
+    if (previousDirection == left) {
+        dfs(root.right, right, steps + 1)
 
         // Or we start new zigzag path from left child
-        dfs(root.left, 0, 0)
+        dfs(root.left, left, 0)
     } else {
-        dfs(root.left, 0, steps + 1)
+        dfs(root.left, left, steps + 1)
 
         // Or we start new zigzag path from right child
-        dfs(root.right, 1, 0)
+        dfs(root.right, right, 0)
     }
 }
 ```