LeetCode 112. 路径总和（Easy）/ 113. 路径总和 II（Medium）/ 437. 路径总和 III（Medium）/ 带权树的直径（Hard）/ 二叉树的路径问题！！！

• 124. 二叉树中的最大路径和（Hard）
• 257. 二叉树的所有【路径】（Easy）/ 打印 N 叉树的所有路径 / 987. 二叉树的【垂序】遍历（H）
• 129. 求根节点到叶节点数字之和（Medium）
• 带权树的直径
• 剑指Offer 34. 二叉树中和为某一值的路径（Medium）
• 968. 监控二叉树（Hard）
  
  题目链接

题解

1. 路径总和 III

代码

# 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:
    ### 0206 递归（176 ms，35.2 MB）
    def pathSum(self, root: TreeNode, sum: int) -> int:
        def dfs(root, sublist):
            if not root: return 0

            # + [root.val]表示列表追加
            sublist = [num + root.val for num in sublist] + [root.val]

            ## sublist.count(sum)与下面代码效果相同
            # count = 0
            # for num in sublist:
            #     if num == sum: count += 1

            # 总数量 = 当前已有数量 + 左子树可能含有的数量 + 右子树可能含有的数量
            return sublist.count(sum) + dfs(root.left, sublist) + dfs(root.right, sublist)
        
        return dfs(root, [])

113. 路径总和 II

• 题解
• 剑指Offer 34. 二叉树中和为某一值的路径（Medium）
  
  
  

class Solution:
    def pathSum(self, root: TreeNode, targetSum: int) -> List[List[int]]:
        ret = list()
        parent = collections.defaultdict(lambda: None)

        def getPath(node: TreeNode):
            tmp = list()
            while node:
                tmp.append(node.val)
                node = parent[node]
            ret.append(tmp[::-1])

        if not root:
            return ret
        
        que_node = collections.deque([root])
        que_total = collections.deque([0])

        while que_node:
            node = que_node.popleft()
            rec = que_total.popleft() + node.val

            if not node.left and not node.right:
                if rec == targetSum:
                    getPath(node)
            else:
                if node.left:
                    parent[node.left] = node
                    que_node.append(node.left)
                    que_total.append(rec)
                if node.right:
                    parent[node.right] = node
                    que_node.append(node.right)
                    que_total.append(rec)

        return ret

112. 路径总和

• 题解
  
  
  

# 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 hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if not root:
            return False

        if not root.left and not root.right:
            return sum == root.val

        # 左、右子树有一个存在路径即可
        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)
        
	# 迭代
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        if not root:
            return False

        que_node = collections.deque([root])
        que_val = collections.deque([root.val])
        while que_node:
            now = que_node.popleft()
            temp = que_val.popleft()
            
            if not now.left and not now.right and temp == sum:
                return True
                
            if now.left:
                que_node.append(now.left)
                que_val.append(now.left.val + temp)
            if now.right:
                que_node.append(now.right)
                que_val.append(now.right.val + temp)

        return False