129. Sum Root to Leaf Numbers

DFS TREE

You are given the root of a binary tree containing digits from 0 to 9 only.

Each root-to-leaf path in the tree represents a number.

• For example, the root-to-leaf path 1 -> 2 -> 3 represents the number 123.

Return the total sum of all root-to-leaf numbers. Test cases are generated so that the answer will fit in a 32-bit integer.

A leaf node is a node with no children.

Example 1:

Input: root = [1,2,3]
Output: 25
Explanation:
The root-to-leaf path 1->2 represents the number 12.
The root-to-leaf path 1->3 represents the number 13.
Therefore, sum = 12 + 13 = 25.

Example 2:

Input: root = [4,9,0,5,1]
Output: 1026
Explanation:
The root-to-leaf path 4->9->5 represents the number 495.
The root-to-leaf path 4->9->1 represents the number 491.
The root-to-leaf path 4->0 represents the number 40.
Therefore, sum = 495 + 491 + 40 = 1026.

Constraints:

• The number of nodes in the tree is in the range [1, 1000].

• 0 <= Node.val <= 9

• The depth of the tree will not exceed 10.

分析

全部res存结果，每条树path存数字，到叶节点时候就加入res

1. 深度优先搜索 (DFS)：

   • 从根节点开始遍历，维护当前路径的数字（current_num）。

   • 遇到叶节点时（左右子节点均为 None），将 current_num 加入总和。

2. 递归参数：

   • node: 当前节点。

   • current_num: 当前路径表示的数字（父节点传递的数字 * 10 + 当前节点值）。

3. 终止条件：

   • 当前节点为 None 时返回。

   • 当前节点为叶节点时，累加 current_num 到结果。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def sumNumbers(self, root: Optional[TreeNode]) -> int:
        res = 0
        def dfs(root, path):
            nonlocal res
            if not root:
                return
            path = path*10 + root.val
            if not root.left and not root.right:  # Only add at leaf nodes
                res += path
                return
            dfs(root.left, path)
            dfs(root.right, path)
            
        dfs(root, 0)
        return res

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def sumNumbers(self, root: Optional[TreeNode]) -> int:
        def dfs(node, current_num):
            if not node:
                return 0
            current_num = current_num * 10 + node.val
            if not node.left and not node.right:
                return current_num
            return dfs(node.left, current_num) + dfs(node.right, current_num)
        
        return dfs(root, 0)