算法---LeetCode 437. 路径总和 III

1. 题目

原题链接

给定一个二叉树，它的每个结点都存放着一个整数值。
找出路径和等于给定数值的路径总数。
路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。
示例：
root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
10
/
5 -3
/ \
3 2 11
/ \
3 -2 1
返回 3。和等于 8 的路径有:

1. 5 -> 3
2. 5 -> 2 -> 1
3. -3 -> 11

Related Topics 树
👍 707 👎 0

2. 题解

2.1 解法1: 双重递归

主要思想: 计算以每个节点为开始结点的符合路径和个数, 最后再相加

    class Solution {
        /**
         * 遍历一遍树, 计算以每个节点开头的最大路径和符合个数, 最后返回结果
         *
         * @param root
         * @param sum
         * @return
         */
        public int pathSum(TreeNode root, int sum) {
            if (root == null) {
                return 0;
            }
            int res = dfs(root, sum);
            int left = pathSum(root.left, sum);
            int right = pathSum(root.right, sum);
            return res + left + right;
        }
        /**
         * 计算以 root 结点为起始结点符合条件的路径总和个数
         *
         * @param root
         * @param sum
         * @return
         */
        public int dfs(TreeNode root, int sum) {
            if (root == null) {
                return 0;
            }
            sum -= root.val;
            int res = sum == 0 ? 1 : 0;
            // 计算左右子树中符合条件的个数
            int left = dfs(root.left, sum);
            int right = dfs(root.right, sum);
            // 返回总结果数, 即当前结点,以及左右返回值的和
            return res + left + right;
        }
    }

参考题解:
两种方法 简单易懂版本
437.路径总和III 递归方式

2.2 单层递归

采取了类似于数组的前n项和的思路，比如sum[4] == sum[1]，那么1到4之间的和肯定为0

对于树的话，采取DFS加回溯，每次访问到一个节点，把该节点加入到当前的pathSum中
然后判断是否存在一个之前的前n项和，其值等于pathSum与sum之差
如果有，就说明现在的前n项和，减去之前的前n项和，等于sum，那么也就是说，这两个点之间的路径和，就是sum

最后要注意的是，记得回溯，把路径和弹出去

    class Solution {

        public int pathSum(TreeNode root, int sum) {
            // key 存储路径和, value 存储该路径和的结点数
            Map<Integer, Integer> map = new HashMap<>();
            // 初始化, 加入第一个元素
            map.put(0, 1);
            return dfs(root, sum, 0, map);
        }

        public int dfs(TreeNode root, int sum, int pathSum, Map<Integer, Integer> map) {
            if (root == null) {
                return 0;
            }
            // 计算路径和
            pathSum += root.val;
            // 判断路径和为 pathSum-sum 的结点数
            int res = map.getOrDefault(pathSum - sum, 0);
            // 将该路径和作为key 的value+1
            map.put(pathSum, map.getOrDefault(pathSum, 0) + 1);
            int left = dfs(root.left, sum, pathSum, map);
            int right = dfs(root.right, sum, pathSum, map);
            // 注意回溯时要消除之前的影响
            map.put(pathSum, map.get(pathSum) - 1);
            return res + left + right;

        }

    }

参考:
两种方法 简单易懂版本
前缀和，递归，回溯