【递归&回溯、前缀和、深度搜索，解决路径总和问题 I II III IV】

唯时

已于 2024-08-21 23:02:22 修改

阅读量656

点赞数 14

分类专栏：算法基础知识文章标签：算法经验分享力扣

于 2024-08-20 23:02:09 首次发布

本文链接：https://blog.csdn.net/weixin_45483322/article/details/141370075

版权

基础知识同时被 2 个专栏收录

15 篇文章 2 订阅

订阅专栏

算法

8 篇文章 1 订阅

订阅专栏

递归，路径总和

题目一：路径总和 https://leetcode.cn/problems/path-sum/

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点是指没有子节点的节点。

示例 1：
在这里插入图片描述

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。
示例 2：
在这里插入图片描述
输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。
示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：

树中节点的数目在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

解题思路：

利用递归思想，遍历所有节点，如果有满足条件的则返回true；
若当前节点不是叶子节点，则将目标值减去当前节点值，并传递到左右节点去判断

代码实现：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if (root == null) {
            return false;
        }
        if (root.left == null && root.right == null) {
            return root.val == targetSum;
        }
        int remain = targetSum - root.val;
        return hasPathSum(root.left, remain) || hasPathSum(root.right, remain);
    }
}

题目二：路径总和IIhttps://leetcode.cn/problems/path-sum-ii/description/

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。

叶子节点是指没有子节点的节点。

示例 1：
在这里插入图片描述

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]
示例 2：
在这里插入图片描述

输入：root = [1,2,3], targetSum = 5
输出：[]
示例 3：

输入：root = [1,2], targetSum = 0
输出：[]

提示：

树中节点总数在范围 [0, 5000] 内
-1000 <= Node.val <= 1000
-1000 <= targetSum <= 1000

解题思路：

回溯法，构造一个backtrack回溯函数，确定递归的参数，以及满足成立的条件
及时回退路径中的元素

代码实现：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        List<Integer> path = new LinkedList<>();
        backtrack(root, targetSum, res, path);
        return res;
    }
    private void backtrack(TreeNode root, int sum, List<List<Integer>> res, List<Integer> path) {
        path.add(root.val);
        //若是到了叶子节点，判断是否满足条件
        if (root.left == null && root.right == null) {
            if (sum == root.val) {
                res.add(new ArrayList(path));
            }
            //不满足直接返回
            return;
        }
        if (root.left != null) {
            backtrack(root.left, sum - root.val, res, path);
            //回溯
            path.removeLast();
        }
        if (root.right != null) {
            backtrack(root.right, sum - root.val, res, path);
            //回溯
            path.removeLast();
        }
    }
}

题目三：路径总和III https://leetcode.cn/problems/path-sum-iii/description/

给定一个二叉树的根节点 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
解题思路

递归回溯法
遍历每一条路径，先从根节点开始，执行递归回溯
依次递归遍历左右节点，执行递归回溯

代码实现：方法1

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    private int count = 0;
    public int pathSum(TreeNode root, long targetSum) {
        if (root == null) {
            return 0;
        }
        backtrack(root, targetSum);
        pathSum(root.left, targetSum);
        pathSum(root.right, targetSum);
        return count;
    }
    //注意sum使用long类型，否则int可能会超出限制
    private void backtrack(TreeNode node, long sum) {
        if (node == null) {
            return;
        }
        if (node.val == sum) {
            count++;
        }
        if (node.left != null) {
            backtrack(node.left, sum - node.val);
        }
        if (node.right != null) {
            backtrack(node.right, sum - node.val);
        }
        return;
    }
}

解法2：

前缀和法
解法一中应该存在许多重复计算，我们定义节点的前缀和为：由根结点到当前结点的路径上所有节点的和。
定义一个map集合存储前缀和的值及对应该前缀和值的个数
当前缀和减去目标值的结果存在前缀和集合中，则表明路径中存在目标值的路径
遍历出栈时，需要在集合中进行删除当前前缀和的操作

代码实现：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int pathSum(TreeNode root, int targetSum) {
        Map<Long, Integer> prefix = new HashMap<Long, Integer>();//用Map保存前缀和
        prefix.put(0L, 1);//初始放入前缀和0，和其1
        return dfs(root, prefix, 0, targetSum);//进入递归
    }

    public int dfs(TreeNode root, Map<Long, Integer> prefix, long curr, int targetSum) {
        if (root == null) return 0;

        int ret = 0;//符合条件的路径条数
        curr += root.val;//当前路径值（前缀和）
        //看看当前路径和 - 目标值，是否等于路径上的一个前缀
        //如果是的话，说明当前路径，去掉某些前缀结点，刚好符合targetSum
        //如果没有，那么ret依然是0
        ret = prefix.getOrDefault(curr - targetSum, 0);
        //将当前路径前缀和，加入到map中
        prefix.put(curr, prefix.getOrDefault(curr, 0) + 1);
        //深度优先
        ret += dfs(root.left, prefix, curr, targetSum);
        ret += dfs(root.right, prefix, curr, targetSum);
        //当此结点的遍历出栈时，要将map中对应的前缀和去掉
        //否则其它路径的前缀和很可能和当前路径的前缀和冲突
        prefix.put(curr, prefix.getOrDefault(curr, 0) - 1);
        //返回符合条件路径条数
        return ret;
    }
}

路径总和IV

在这里插入图片描述
解题思路：
如果题目给定的是二叉树的根节点，那么直接 dfs 即可。

现在题目给的是用整数来表示的节点。

画出深度为 4 的完全二叉树：

在这里插入图片描述
其中，数字表示该节点在当前所在层的位置。

通过观察可知，对于某一个节点来说，如果它的位置编号为 i，那么，它的左子节点的位置编号为 i × 2 - 1，它的右子节点的位置编号为左子节点位置编号加一。

于是，算法流程为：

先把给定的节点用 Map 记录起来，key 为整数的前两位，value 为整数的后一位，即 key 为位置信息，value 为权值。map.put(num / 10, num % 10);
定义一个全局遍历 ans 表示所有的路径和，定义一个局部变量 sum 表示一条路径上的权值和。
从根节点开始 dfs：
- 取出当前节点 node 的权值加入到 sum 中：sum += map.get(node);
- 取出当前节点 node 的位置信息：depth = node / 10; pos = node % 10;
- 计算出左右子树的位置信息：left = (depth + 1) * 10 + pos * 2 - 1;right = left + 1;
- 如果 left 和 right 均不在 map 中，说明一条路径计算完毕，ans += sum; 否则，继续向下 dfs。

代码实现：

class Solution {
        private int ans = 0;
    private Map<Integer, Integer> map;

    public int pathSum(int[] nums) {
        // key 为深度和位置， value 为权值
        map = new HashMap<>();
        for (int num : nums) {
            map.put(num / 10, num % 10);
        }
        dfs(nums[0] / 10, 0);
        return ans;
    }

    /**
     * @param node
     * @param sum  包括 num 之前的总和
     */
    private void dfs(int node, int sum) {
        if (!map.containsKey(node)) {
            return;
        }
        sum += map.get(node);
        int depth = node / 10;
        int pos = node % 10;
        //下一层左右节点key值
        int left = (depth + 1) * 10 + pos * 2 - 1;
        int right = left + 1;
        if (!map.containsKey(left) && !map.containsKey(right)) {
            // 当前节点是叶子节点
            ans += sum;
        } else {
            dfs(left, sum);
            dfs(right, sum);
        }
    }
}