路径总和相关

核心思想就是回溯，二叉树的回溯，模板都差不多

112. 路径总和

根节点到叶子节点

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ，判断该树中是否存在 根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum

# 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, targetSum: int) -> bool:
        def dfs(root, target):
            if not root:
                return False
            target -= root.val
            if target == 0 and not root.left and not root.right:
                return True
            left = dfs(root.left, target)
            right = dfs(root.right, target)
            target += root.val
            return left or right
        if not root:
            return False
        return dfs(root, targetSum)

剑指 Offer 34. 二叉树中和为某一值的路径

根节点到叶子节点

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。

# 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 pathSum(self, root: TreeNode, target: int) -> List[List[int]]:
        def dfs(root, target, path):
            if not root:
                return
            path.append(root.val)
            target -= root.val
            if target == 0 and not root.left and not root.right:
                res.append(path[:])
            dfs(root.left, target, path)
            dfs(root.right, target, path)
            path.pop()
            target += root.val
        path, res = [], []
        dfs(root, target, path)
        return res

124. 二叉树中的最大路径和

不是根节点到叶子节点

路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。

# 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 __init__(self):
        self.res = -float("inf") 
    def maxPathSum(self, root: TreeNode) -> int:
        def dfs(root):
            if not root:
                return 0
            left = max(dfs(root.left), 0)
            right = max(dfs(root.right), 0)
            self.res = max(self.res, left + right + root.val)
            return max(left, right) + root.val
        dfs(root)
        return self.res

437. 路径总和 III

不是根节点到叶子节点

给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。
路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）

# 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 __init__(self):
        self.res = 0
    def pathSum(self, root: TreeNode, targetSum: int) -> int:
        
        def dfs(root, pre_hash, target):
            if not root:
                return
            target += root.val
            if pre_hash[target-targetSum]:
                self.res += pre_hash[target-targetSum]
            pre_hash[target] += 1
            dfs(root.left, pre_hash, target)
            dfs(root.right, pre_hash, target)
            pre_hash[target] -= 1
            target -= root.val
        pre_hash = collections.defaultdict(int)
        pre_hash[0] = 1
        dfs(root, pre_hash, 0)
        return self.res