• 小知识，大挑战！本文正在参与“程序员必备小知识”创作活动。
• 本文已参与「掘力星计划」，赢取创作大礼包，挑战创作激励金。

leetcode-437-路径总和III

[博客链接]

菜🐔的学习之路

掘金首页

[题目链接]

题目链接

[github地址]

github地址

[题目描述]

给定一个二叉树的根节点 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]
• -109 <= Node.val <= 109 
• -1000 <= targetSum <= 1000 

思路一：dfs

• 常规往下递归求和
• 满足条件即可

        public int pathSum(TreeNode root, int targetSum) {
            target = targetSum;
            dfsNode(root);
            return res;
        }

        public void dfsNode(TreeNode root) {
            if (root == null) {
                return;
            }
            dfs(root, root.val);
            dfsNode(root.left);
            dfsNode(root.right);
        }

        public void dfs(TreeNode root, int tmp) {
            if (tmp == target) {
                res += 1;
            }
            if (root.left != null) {
                dfs(root.left, tmp + root.left.val);
            }
            if (root.right != null) {
                dfs(root.right, tmp + root.right.val);
            }
        }

• 时间复杂度O($n^2$)
• 空间复杂度O(n)

---

思路二：前缀和

• 上述思路包含重复计算的路径
• 可以通过前缀和来进行减法计算
• 因为要计算跟节点的原因所以优先存入map(0,1)
• 同时需要对跨节点路径进行回溯

        Map<Integer, Integer> map = new HashMap<>();

        public int pathSum(TreeNode root, int targetSum) {
            if (root == null) {
                return 0;
            }
            target = targetSum;
            map.put(0, 1);
            dfs(root, map, 0);
            return res;
        }

        public void dfs(TreeNode root, Map<Integer, Integer> map, int tmp) {
            if (root == null) {
                return;
            }
            tmp += root.val;
            res += map.getOrDefault(tmp - target, 0);
            map.put(tmp, map.getOrDefault(tmp, 0) + 1);
            if (root.left != null) dfs(root.left, map, tmp);
            if (root.right != null) dfs(root.right, map, tmp );
            //回溯
            map.put(tmp, map.getOrDefault(tmp, 0) - 1);
        }

• 时间复杂度O(n)
• 空间复杂度O(n)