Add new binary tree problems

Author: enginebai

leetcode/112.path-sum.md

@@ -71,4 +71,6 @@ private fun dfs(root: TreeNode?, sum: Int) {
 ```
 
 * **Time Complexity**: `O(n)`.
-* **Space Complexity**: `O(n)`.
+* **Space Complexity**: `O(n)`.
+
+> 只需要用给定和target减去节点值，最终结束条件判断target==0即可

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

@@ -0,0 +1,137 @@
+# [129. Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers/description/)
+
+# Test Cases
+### Normal Cases
+```
+Input: 
+         1
+      /     \
+    2        3
+
+Output: 12 + 13 = 25
+```
+### Edge / Corner Cases
+* Not full or complete binary tree
+```
+Input: 
+           2
+        /     \ 
+       3       4
+     /   \
+    5     7
+         /
+        1
+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.
+
+![](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/
+
+Steps by steps:
+![](../media/129.sum-root-to-leaf-numbers-1.png)
+![](../media/129.sum-root-to-leaf-numbers-2.png)
+![](../media/129.sum-root-to-leaf-numbers-3.png)
+![](../media/129.sum-root-to-leaf-numbers-4.png)
+```kotlin
+fun sumNumbers(root: TreeNode?): Int {
+    return dfs(root, 0)
+}
+
+private fun dfs(root: TreeNode?, num: Int): Int {
+    if (root == null) return 0
+    var newNum = num * 10 + root.`val`
+
+    if (root.left == null && root.right == null) {
+        return newNum
+    }
+
+    val left = dfs(root.left, newNum)
+    val right = dfs(root.right, newNum)
+    return left + right
+}
+```
+
+* **Time Complexity:** `O(n)`
+* **Time Complexity:** `O(h)`, where `h` is the height of the tree.
+
+## Backtracking
+```kotlin
+private var sum = 0
+fun sumNumbers(root: TreeNode?): Int {
+    dfs(root, ArrayDeque<Int>())
+    return sum
+}
+
+private fun dfs(root: TreeNode?, numbers: ArrayDeque<Int>) {
+    if (root == null) return
+
+    numbers.addLast(root.`val`)
+    if (root.left == null && root.right == null) {
+        sum += numbers.toInt()
+        numbers.removeLast()
+        return
+    }
+    dfs(root.left, numbers)
+    dfs(root.right, numbers)
+    numbers.removeLast()
+}
+
+private fun ArrayDeque<Int>.toInt(): Int {
+    var num = 0
+    for (i in 0 until this.size) {
+        num = num * 10 + this[i]
+    }
+    return num
+}
+```
+
+* **Time Complexity:** `O(n)`
+* **Time Complexity:** `O(n)`
+
+## BFS
+For every node, we enqueue the current number and the node to the queue. If the node is a leaf node, we sum the number.
+
+* For `2 -> 3 -> 5`, we traverse to build the number `235`: 
+  * We enqueue `(2 to 0)`.
+  * At `2`, the number will become `0 * 10 + 2` -> `2`. We enqueue `(3 to 2)`.
+  * At `3`, the number will become `2 * 10 + 3` -> `23`. We enqueue `(5 to 23)`.
+  * At `5`, the number will become `23 * 10 + 5` -> `235`. And it's a leaf node, so we sum it.
+
+```kotlin
+fun sumNumbers(root: TreeNode?): Int {
+    if (root == null) return 0
+    var totalSum = 0
+    val queue = ArrayDeque<Pair<TreeNode, Int>>()
+    queue.addLast(root to 0)
+    while (queue.isNotEmpty()) {
+        val pair = queue.removeFirst()
+        val node = pair.first
+        val sum = pair.second
+
+        val newSum = sum * 10 + node.`val`
+        if (node.left == null && node.right == null) {
+            totalSum += newSum
+            continue
+        }
+
+        if (node.left != null) {
+            queue.addLast(node.left to newSum)
+        }
+
+        if (node.right != null) {
+            queue.addLast(node.right to newSum)
+        }
+    }
+    return totalSum
+}
+```
+
+* **Time Complexity:** `O(n)`
+* **Time Complexity:** `O(n)`, where `n` is the number of nodes in the tree.

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

@@ -0,0 +1,93 @@
+# [1339. Maximum Product of Splitted Binary Tree](https://leetcode.com/problems/maximum-product-of-splitted-binary-tree/description/)
+
+## 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
+
+// Can split into two cases
+     2             2
+      \     or    /
+   3   4         3   4
+
+ = 3 * 6    or   5 * 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)
+
+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
+               \
+sum(left)    sum(right)
+```
+* Split right = `(total sum - sum(right)) * sum(right)`
+```js
+        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.
+
+```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()
+}
+
+private fun sum(root: TreeNode?): Long {
+    if (root == null) return 0L
+    //      5
+    //    /   \
+    //   2     3
+    // total = 10
+    val left = sum(root.left) // 2
+    val right = sum(root.right) // 3
+
+    val leftSplit = left * (total - left)       // 2 * (10 - 2)
+    val rightSplit = (total - right) * right    // (10 - 3) * 3
+    result = maxOf(result, maxOf(leftSplit, rightSplit))
+
+    return root.`val`.toLong()+ left + right
+}
+```
+
+Or the same idea, we can split at root node:
+```js
+ parent
+    \
+     X  // split here
+      \
+       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()
+}
+
+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))
+    return currentSum
+}
+```
+
+* **Time Complexity:** `O(n)`
+* **Space Complexity:** `O(n)`

leetcode/1448.count-good-nodes-in-binary-tree.md

@@ -0,0 +1,23 @@
+# [1448. Count Good Nodes in Binary Tree](https://leetcode.com/problems/count-good-nodes-in-binary-tree/description/)
+
+## DFS
+We just trace the current maximum value from the root to the current node.
+
+```kotlin
+fun goodNodes(root: TreeNode?): Int {
+    return dfs(root, root.`val`)
+}
+
+private fun dfs(root: TreeNode?, max: Int): Int {
+    if (root == null) return 0
+    var count = if (root.`val` >= max) 1 else 0
+
+    val nextMax = maxOf(max, root.`val`)
+    count += dfs(root.left, nextMax)
+    count += dfs(root.right, nextMax)
+    return count
+}
+```
+
+* **Time Complexity:** `O(n)` where `n` is the number of nodes in the tree.
+* **Space Complexity:** `O(h)` where `h` is the height of the tree.

leetcode/1530.number-of-good-leaf-nodes-pairs.md

@@ -0,0 +1,45 @@
+# [1530. Number of Good Leaf Nodes Pairs](https://leetcode.com/problems/number-of-good-leaf-nodes-pairs/description/)
+
+## Postorder
+We have to keep track of the number of leaf nodes with a particular distance for each root node.
+
+> TODO: Add explanation and Kotlin code.
+
+```python
+class Solution:
+    def countPairs(self, root: TreeNode, distance: int) -> int:
+        self.result = 0
+        
+        # Helper function to perform DFS
+        def dfs(node):
+            # If it's a null node, return an empty list (no leaves)
+            if not node:
+                return [0] * (distance + 1)
+            
+            # If it's a leaf node, return distance 1 (leaf nodes are distance 1 from themselves)
+            if not node.left and not node.right:
+                leaf_distances = [0] * (distance + 1)
+                leaf_distances[1] = 1  # Leaf is at distance 1
+                return leaf_distances
+            
+            # Perform DFS on left and right children
+            left_distances = dfs(node.left)
+            right_distances = dfs(node.right)
+            
+            # Count good pairs (pairs whose distance is <= given distance)
+            for l_dist in range(1, distance + 1):
+                for r_dist in range(1, distance + 1):
+                    if l_dist + r_dist <= distance:
+                        self.result += left_distances[l_dist] * right_distances[r_dist]
+            
+            # Prepare the distance array for the current node
+            current_distances = [0] * (distance + 1)
+            for i in range(1, distance):
+                current_distances[i + 1] = left_distances[i] + right_distances[i]
+            
+            return current_distances
+        
+        # Start DFS from root
+        dfs(root)
+        return self.result
+```