路径总和 III-前缀和&dfs

原创已于 2023-08-24 01:23:36 修改 · 166 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#深度优先 #算法

于 2023-08-24 01:22:29 首次发布

LeetCode 专栏收录该内容

31 篇文章

订阅专栏

文章描述了一种算法，用于计算给定二叉树中节点值之和等于目标值的路径数目，使用深度优先搜索（DFS）策略递归遍历节点并计数。时间复杂度为O(n^2)，空间复杂度为O(N)。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

示例 1：

输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
输出：3
解释：和等于 8 的路径有 3 条，如图所示。
示例 2：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：3

提示:

二叉树的节点个数的范围是 [0,1000]
$10^9$ <= Node.val <= $10^9$
-1000 <= targetSum <= 1000

深度优先搜索

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

我们首先定义 $roo tS u m (p, v a l)$ 表示以节点 p 为起点向下且满足路径总和为 $v a l$ 的路径数目。我们对二叉树上每个节点 p 求出 $roo tS u m (p, t a r g e tS u m)$ ,然后对这些路径数目求和即为返回结果。
我们对节点 p 求 $roo tS u m (p, t a r g e tS u m)$ 时，以当前节点 p 为目标路径的起点递归向下进行搜索。假设当前的节点 p 的值为 $v a l$ ，我们对左子树和右子树进行递归搜索，对节点 p 的左孩子节点 $p_l$ 求出 $rootSum(p_l, targetSum-val)$ 以及对右孩子节点 $p_r$ 求出 $roo tS u m (p, t a r g e tS u m - v a l)$ 。节点 p 的 $roo tS u m (p, t a r g e tS u m)$ 即等于 $rootSum(p_l, targetSum-val)$ 与 $rootSum(p_r, targetSum-val)$ 之和，同时我们还需要判断一下当前节点 p 的值是否刚好等于 $t a r g e tS u m$ 。
我们采用递归遍历二叉树的每个节点 p，对节点 p 求 $roo tS u m$ ，然后将每个节点所有求的值进行相加求和返回。

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) -> int:
        if not root:
            return 0

        ret = self.dfs(root, targetSum)
        ret += self.pathSum(root.left, targetSum)
        ret += self.pathSum(root.right, targetSum)
        return ret


    def dfs(self, node: TreeNode, targetSum: int) -> int:
        if not node:
            return 0

        ret = 0
        if node.val == targetSum:
            ret += 1

        ret += self.dfs(node.left, targetSum - node.val)
        ret += self.dfs(node.right, targetSum - node.val)

        return ret


if __name__ == '__main__':
    s = Solution()
    root = TreeNode(10, TreeNode(5,TreeNode(3, TreeNode(3), TreeNode(-2)), TreeNode(2, None, TreeNode(1))), TreeNode(-3, None, TreeNode(11)))
    print(s.pathSum(root, 8))

复杂度分析

时间复杂度： $O(n^2)$ ，其中 N 为该二叉树节点的个数。对于每一个节点，求以该节点为起点的路径数目时，则需要遍历以该节点为根节点的子树的所有节点，因此求该路径所花费的最大时间为 $O (N)$ ，我们会对每个节点都求一次以该节点为起点的路径数目，因此时间复杂度为 $O(n^2)$
空间复杂度： $O (N)$ ，考虑到递归需要在栈上开辟空间。