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

深度优先搜索 (DFS)：
- 从根节点开始遍历，维护当前路径的数字（current_num）。
- 遇到叶节点时（左右子节点均为 None），将 current_num 加入总和。
递归参数：
- node: 当前节点。
- current_num: 当前路径表示的数字（父节点传递的数字 * 10 + 当前节点值）。
终止条件：
- 当前节点为 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)

Previous1570. Dot Product of Two Sparse Vectors Next938. Range Sum of BST

Last updated 3 days ago

Was this helpful?

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.

# 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)