每日一道Leetcode-路径总和系列【二叉树｜递归｜回溯】

# 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:
    	# 根节点到叶结点范围找到一条满足的即可
        # 时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。
        # 空间复杂度：O(H)，其中 H 是树的高度。空间复杂度主要取决于递归时栈空间的开销，最坏情况下，树呈现链状，空间复杂度为O(N)。平均情况下树的高度与节点数的对数正相关，空间复杂度O(logN)。
        def backtrack(root,resSum):
            if not root:
                return False
            res_target = resSum-root.val
            if res_target==0 and not root.left and not root.right:
                return True
            # 否则就看左子树或者右子树中是否有满足的条件
            return backtrack(root.left,res_target) or backtrack(root.right,res_target)
        
        return backtrack(root,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 pathSum(self, root: TreeNode, targetSum: int) -> List[List[int]]:
        # 使用回溯法｜DFS｜递归
        # 根节点到叶节点找到所有满足条件的路径
        # 时间复杂度O(N) 空间复杂度O(N)
        # N为二叉树的节点数，先序遍历需要遍历所有节点
        # 最差情况下，即树退化为链表时，path 存储所有树节点，使用O(N)额外空间
        res, path = [],[]
        def backtrack(root,sumData):
            if not root:
                return 
            # 入队
            path.append(root.val)
            target = sumData-root.val
            # 因为找从根节点到叶子结点的路径总和，所以既要判断当前剩余值为0，从事也要判断此时结点已经是叶子结点
            if target==0 and not root.left and not root.right:
                # 记录路径时若直接执行 res.append(path) ，则是将 path 对象加入了 res ；后续 path 改变时， res 中的 path 对象也会随之改变。
                # 正确做法：res.append(list(path)) ，相当于复制了一个 path 并加入到 res 
                # 这个和target.copy()性质一致
                res.append(list(path))
            backtrack(root.left,target)
            backtrack(root.right,target)
            # 出队
            path.pop()

        backtrack(root,targetSum)
        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 pathSum(self, root: TreeNode, sum: int) -> int:
    	# 任意节点到任意节点找到满足条件的路径总数
        # 两个递归嵌套 O(N^2)
        # 找以当前节点为头节点的符合条件的路径数
        # 找以当前节点的左子树为头节点的符合条件的路径数
        # 找以当前节点的右子树为头节点的符合条件的路径数
        def countPath(root,target):
            # 递归左右子树剩余的target
            if not root:
                return 0
            res_target = target - root.val
            if res_target == 0:
                # 找到路径，返回1条
                res = 1
            else:
                res = 0
            return res + countPath(root.left,res_target) + countPath(root.right,res_target)

        if not root:
            return 0
        result = countPath(root,sum)
        left = self.pathSum(root.left,sum)
        right = self.pathSum(root.right,sum)
        return result + left + right