回溯算法详解

什么是回溯算法

实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就往回移动（回溯），尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。

注意：

1. 由于采用回溯法求解时存在退回到祖先结点的过程，所以需要保存搜索过的结点。通常有两种：第一种用子定义栈来保存；第二种采用递归方法。
2. 用回溯法通常采用两种策略避免无效搜索。第一种用约束函数在扩展结点处剪除不满足约束条件的路径；二：用限界函数剪去得不到问题的解或最优解的路径。这两类函数统称为剪枝函数

回溯法与深度优先遍历的区别

1. 访问的次序不同：深度优先遍历的目的是“遍历”，本质是无序的，重要的是是否被访问过，因此在实现上只需要对于每个位置是否被访问就足够了。回溯法的目的是“求解过程”，本质是有序的，也就是说必须每一步都是要求的次序。
2. 访问次数不同：深度优先遍历对已经访问过的顶点不再访问。回溯法中已经访问过的顶点可能再次访问。
3. 剪枝不同：深度优先遍历不含剪枝。

用回溯法求解问题的公式

void backtrack(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

排列问题

例题：leetcode 46.全排列

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

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

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> list = new ArrayList<>();
        backtrack(res, list, nums);
        return res;
    }
    public void backtrack(List<List<Integer>> res, List<Integer> list, int[] nums){
        if(list.size() == nums.length){
            res.add(new ArrayList<Integer>(list));
            return;
        }
        for(int num : nums){
            if(!list.contains(num)){
                list.add(num);
                backtrack(res, list, nums);
                list.remove(list.size() - 1);
            }
        }
    }
}

组合问题

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

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

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：
输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtrack(candidates,target,0,0);
        return res;
    }
    //回溯
    //函数参数返回值
    //确定返回值
    //单层搜索逻辑
    //未剪枝
    public void backtrack(int[] candidates, int target, int sum, int startIndex){//sum是path的和
        //终止条件
        if(sum > target){
            return;
        }
        if(sum == target){
            res.add(new ArrayList<>(path));
            return;
        }
        //剪枝
        for(int i = startIndex; i < candidates.length; i++){
            if(sum + candidates[i] > target){
                break;
            }
            path.add(candidates[i]);
            sum += candidates[i];
            backtrack(candidates, target, sum, i);
            sum -= candidates[i];
            path.remove(path.size() - 1);
        }
        //未剪枝
        // for(int i = startIndex; i < candidates.length; i++){
        //     path.add(candidates[i]);
        //     sum += candidates[i];
        //     backtrack(candidates, target, sum, i);
        //     sum -= candidates[i];
        //     path.remove(path.size() - 1);
        // }
    }
}

例题：leetcode 77.组合
给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。
示例 ：
输入：n = 4, k = 2
输出：
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> res  = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        backtrack(res, path, n, k, 1);
        return res;
    }

    public void backtrack(List<List<Integer>> res, List<Integer> path, int n, int k, int startIndex){
        //终止条件
        if(path.size() == k){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = startIndex; i <= n - (k - path.size()) + 1; i++){//剪枝之前i<=n  剪枝操作是要在i的范围n - (k - path.size()) + 1上                                               
            path.add(i);
            backtrack(res, path, n, k, i + 1);
            path.remove(path.size() - 1);
        }
    }
}