从leetcoe100几道题掌握回溯算法

什么是回溯？

回溯算法是一种基于试错思想的搜索算法，主要用于解决约束满足问题（Constraint Satisfaction Problems, CSPs），例如排列组合问题、迷宫求解、八皇后问题、数独游戏等。它的基本思路是从问题的根节点出发，尝试每一种可能性分支，直到找到解决方案为止；若某一路径不可行，则撤销选择，返回上一层次继续探索未遍历过的分支，这一过程称为“回溯”。

回溯算法的基本步骤如下：
递归探索： 从起始点开始，沿着一棵潜在的解树向下探索，尝试构建一个完整的解。

可行性判断： 在每一个决策点，检查当前的选择是否满足问题的约束条件。如果不满足，则立即放弃这条路径，转而去探索另一条路径。

回退： 当到达叶子节点或发现当前路径无法产生有效解时，算法会撤销最近做出的选择，回到上一层决策点，尝试其他的选项。

终止条件： 当找到一个满足所有约束条件的完整解时，根据问题的需求决定是否停止搜索或是继续寻找所有可能的解。

回溯算法的特点：
全面性：能穷尽所有可能的解，适用于需要找到所有解或最优解的问题场景。
灵活性：可以通过调整剪枝策略来优化搜索效率，避免不必要的计算。
复杂度：时间复杂度较高，特别是在没有良好剪枝的情况下，可能需要指数级别的计算量。

---

用回溯解决leetcode热题

1、力扣46.全排列

题目描述： 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1： 输入：nums = [1,2,3] 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2： 输入：nums = [0,1] 输出：[[0,1],[1,0]]
示例 3： 输入：nums = [1] 输出：[[1]]

提示：
1 <= nums.length <= 6
-10 <= nums[i] <= 10 nums 中的所有整数 互不相同

题解思路：
全排列问题，很明显的思路就是把所有的结果全部穷举出来。
这个问题可以看作有 n 个排列成一行的空格，然后我们从左往右依此填入题目给定的 n 个数，每个数只能使用一次。思路很简单，但很多同学可能确无法下笔完成这个程序。普通的迭代方法很难完成，但是学会了回溯的思路，还是比较简单的，下面我们看题解。

按照上面的回溯算法的思路，我们需要使用递归，并找到递归的终止条件，在递归的方法中判断可行性并进行回溯，完成全排列。代码如下

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>(); // 定义结果集
        backtrack(nums, res, new ArrayList<>()); // 递归
        return res;
    }
    
    // 回溯
    public void backtrack(int[] nums, List<List<Integer>> res, List<Integer> list) {
        if (list.size() == nums.length) { // 递归终止条件，list是一次结果，当list的size和nums的length相同时，说明可以将一次的结果放入结果集中了
            res.add(new ArrayList<>(list));
            return;
        }
        for (int i = 0; i < nums.length; i++) { // 循环数组，尝试将数组的项放入结果中
            if (list.contains(nums[i])) {
                continue;
            }
            list.add(nums[i]); // 加入list
            backtrack(nums, res, list); // 递归
            list.remove(list.size() - 1); // 回溯，尝试后将本位置放置的内容删除，循环尝试所有值
        }
    }
}

2、力扣78.子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的 子集 （幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例 1：
输入：nums = [1,2,3] 输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2：
输入：nums = [0] 输出：[[],[0]]
提示：
1 <= nums.length <= 10
-10 <= nums[i] <= 10 nums 中的所有元素 互不相同

题解思路：
回溯算法也常用于在求子集中，求子集的思路可以先定义子集的长度1-n，然后穷举出每个长度的不同子集，使用数组中的项对子集进行填充

同样的回溯算法的思路，我们需要使用递归，并找到递归的终止条件，在递归的方法中判断可行性并进行回溯，完成求子集。代码如下

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>(); // 结果集
        backtrack(nums, 0, new ArrayList<>(), res);  // 递归
        return res;
    }

    public void backtrack(int[] nums, int start, List<Integer> list, List<List<Integer>> res) {
        if (start == nums.length) {  // 当长度等于数据长度了就结束递归
            res.add(new ArrayList<>(list));
            return;
        }
        list.add(nums[start]);  // 加入list
        backtrack(nums, start + 1, list, res);  // 递归
        list.remove(list.size() - 1);  //回溯
        
        backtrack(nums, start + 1, list, res);  // 子集长度+1进行递归
    }
}

3、力扣39.组合总合

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数
target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。
> 示例 1：
输入：candidates = [2,3,6,7], target = 7 输出：[[2,2,3],[7]] 解释： 2 和 3
可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。 7 也是一个候选， 7 = 7 。 仅有这两种组合。
> 示例 2：
输入: candidates = [2,3,5], target = 8 输出: [[2,2,2,2],[2,3,3],[3,5]]
> 示例3：
输入: candidates = [2], target = 1 输出: []
提示：
1 <= candidates.length <= 30 2 <= candidates[i] <= 40 candidates 的所有元素
互不相同 1 <= target <= 40

题解思路：
本题可以看作是求子集的一个变化，当你会解全排列这题也是可以解出来的，只要找到所有排列中子集的和为target的结果保存即可。

同样的回溯算法的思路，我们需要使用递归，并找到递归的终止条件，在递归的方法中判断可行性并进行回溯，完成求子集并找到子集和为target的子集。代码如下

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(candidates); // 对数组排序，可以减少复杂度
        backtrack(res, target, candidates, 0, new ArrayList<>()); // 递归
        return res;
    }

    public void backtrack(List<List<Integer>> res, int target, int[] candidates, int start, List<Integer> list) {
       int sum = list.stream().mapToInt(Integer::intValue).sum(); // 对list求和
       if ( sum == target) {  // 和为target，则保存这个结果
           res.add(new ArrayList<>(list));
           return;
       }

       if (sum > target) { // 剪枝
           return;
       }

       for (int i = start; i < candidates.length; i++) { // 遍历数组
           list.add(candidates[i]);  // 加入list
           backtrack(res, target, candidates, i, list);  //递归
           list.remove(list.size() - 1);  //回溯
       }
    }
}

总结

总的来说，回溯算法是一种强大的工具，尤其适用于解决那些解空间大、约束复杂的离散优化问题。