当前位置：首页 > news >正文

python-leetcode 47.路径总和III

news 来源：原创 2025/6/9 20:39:25

题目：

给定一个二叉树的根结点root,和一个整数targetSum,求该二叉树力节点值之和等于targetSum的路径数目。

路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）

方法一：深度优先搜索

首先想到的解法是穷举所有的可能，访问每一个节点 node，检测以 node 为起始节点且向下延深的路径有多少种，递归遍历每一个节点的所有可能的路径，然后将这些路径数目加起来即为返回结果。

首先定义 rootSum(p,val) 表示以节点 p 为起点向下且满足路径总和为 val 的路径数目，对二叉树上每个节点 p 求出 rootSum(p,targetSum)，然后对这些路径数目求和即为返回结果。

对节点 p 求 rootSum(p,targetSum) 时，以当前节点 p 为目标路径的起点递归向下进行搜索。假设当前的节点 p 的值为 val，对左子树和右子树进行递归搜索，对节点 p 的左孩子节点 pi求出rootSum(pl,targetSum-val).以l及对右孩子节点P求出rootSum(pr,targetSum-val),节点 p 的root(p.targetSum)即等于rootSum(pl,targetSum-val)与rootSum(pr,targetSum-val)之和同时我们还需要判断一下当前节点 p 的值是否刚好等于 targetSum

采用递归遍历二叉树的每个节点 p，对节点 p 求 rootSum(p,val)，然后将每个节点所有求的值进行相加求和返回。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def pathSum(self, root, targetSum):
        """
        :type root: Optional[TreeNode]
        :type targetSum: int
        :rtype: int
        """
        def rootSum(root,targetSum):  #计算从当前 root 节点开始的路径数量
            if root is None:
                return 0
            ret=0  #初始化计数变量 ret，用于存储当前路径满足 targetSum 的数量
            if root.val==targetSum: #如果当前节点 root 的值等于 targetSum
                ret+=1
            ret+=rootSum(root.left,targetSum-root.val)#递归计算左子树
            ret+=rootSum(root.right,targetSum-root.val)#递归计算右子树
            return ret
        if root is None:
            return 0
        ret=rootSum(root,targetSum)#计算从 root 开始的路径数量
        ret+=self.pathSum(root.left,targetSum)#递归计算左子树的路径和，不一定非得从root开始
        ret+=self.pathSum(root.right,targetSum)#递归计算右子树的路径和，不一定非得从root开始
        return ret

时间复杂度：O(N2)N 为该二叉树节点的个数。对于每一个节点，求以该节点为起点的路径数目时，则需要遍历以该节点为根节点的子树的所有节点，因此求该路径所花费的最大时间为 O(N)，我们会对每个节点都求一次以该节点为起点的路径数目，因此时间复杂度为 O(N2)

方法二：前缀和

定义节点的前缀和为：由根结点到当前结点的路径上所有节点的和，利用先序遍历二叉树，记录下根节点 root 到当前节点 p 的路径上除当前节点以外所有节点的前缀和，在已保存的路径前缀和中查找是否存在前缀和刚好等于当前节点到根节点的前缀和 curr 减去 targetSum

对于空路径我们也需要保存预先处理一下，此时因为空路径不经过任何节点，因此它的前缀和为 0

假设根节点为 root，我们当前刚好访问节点 node，则此时从根节点 root 到节点 node 的路径（无重复节点）刚好为 root→p1 →p2→…→pk→node，此时我们可以已经保存了节点p1,p2 ,p3 ,…,p k的前缀和，并且计算出了节点 node 的前缀和

假设当前从根节点 root 到节点 node 的前缀和为 curr，则此时我们在已保存的前缀和查找是否存在前缀和刚好等于 curr−targetSum。

假设从根节点 root 到节点 node 的路径中存在节点 p i到根节点 root 的前缀和为 curr−targetSum则节点 p i+1 到 node 的路径上所有节点的和一定为 targetSum

利用深度搜索遍历树，当我们退出当前节点时，我们需要及时更新已经保存的前缀和

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

class Solution(object):
    def pathSum(self, root, targetSum):
        """
        :type root: Optional[TreeNode]
        :type targetSum: int
        :rtype: int
        """
        prefix=collections.defaultdict(int)  #创建具有默认值的字典，用于存储前缀和的计数
#当访问一个不存在的键时，它会默认返回 int() 的值，即 0
        prefix[0]=1  #表示 当前缀和为 0 时，有 1 种方法（即不选择任何节点）
        def dfs(root,curr):  #深度优先搜索（DFS）遍历二叉树,代表从根节点到当前节点的路径和
            if not root:
                return 0
            ret=0 #初始化 ret，用于存储当前路径中符合 targetSum 的路径数量
            curr+=root.val #累加当前节点值 root.val，得到当前路径和
            ret+=prefix[curr-targetSum]#计算当前前缀和 curr 与 targetSum 的差值
            prefix[curr]+=1 #更新 prefix 哈希表，增加当前路径和 curr 的出现次数
            ret+=dfs(root.left,curr) #递归计算左子树的路径数目
            ret+=dfs(root.right,curr)#递归计算右子树的路径数目
            prefix[curr]-=1 #prefix[curr]仅用于当前DFS路径，所以要在返回上一层时减去当前值
            return ret
        return dfs(root,0)#调用 dfs(root, 0)，从 root 节点开始遍历，初始路径和 curr 设为 0

时间复杂度：O(N)

空间复杂度：O(N)

源自力扣官方题解