回溯算法的奥秘（LeetCode），组合77题、216题、40题

疫情如潮水，顺势而来、又逆势而去。反反复复，希望疫情快点消失——

回溯是递归的伴生产物，在前面的二叉树遍历中，我们发现，后续遍历就有一个回溯的思想。现在我们来仔细的学习这个算法思想。

回溯算法结合着递归使用，主要确定三个点：

1. 返回值，绝大多数情况是void。
2. 结束条件，在题目中其实它就已经高数你了结束条件，隐式的。
3. 参数，这个一下子式确定不了的，边写边填。

  首先77题：指定区间，指定每个子集的个数。

定义一个集合用来存储子集。再定义一个子集集合存储元素。首先结束条件当让是子集长度等于k了。然后加入到ans里面。for循环用来确定递归的宽度。

class Solution {
 List<List<Integer>> ans = new ArrayList<>();
    List<Integer> list = new ArrayList<>();

    public List<List<Integer>> combine(int n, int k) {
        dfs(k, n, 1);
        return ans;
    }

    private void dfs(int k, int n, int p) {
        if (list.size() == k) {
            ans.add(new ArrayList<>(list));
            return;
        }
        for (int i = p; i <= n; i++) {
            list.add(i);
            dfs(k, n, i + 1);
            list.remove(list.size() - 1);
        }
    }
}

递归函数后面接上回溯，也就是下一次循环初始化。

216题多了一个条件，子集元素相加等于指定tar.

所以在结束的时候多一个判断，回溯的时候多一个回溯：

class Solution {
 List<List<Integer>> ans = new ArrayList<>();
    List<Integer> list = new ArrayList<>();
    int sum = 0;

    public List<List<Integer>> combinationSum3(int k, int n) {
        dfs(k, n, 1);
        return ans;
    }

    private void dfs(int k, int tar, int p) {
        if (list.size() == k) {
            if (sum == tar) {
                ans.add(new ArrayList<>(list));
                return;
            }
        }
        for (int i = p; i <=9; i++) {
            if (sum+i> tar || list.size() > k) {
                break;
            }
            sum += i;
            list.add(i);
            dfs(k, tar, i + 1);
            sum -= i;
            list.remove(list.size() - 1);
        }
    }
}

当子集长度大于k的时候，不满住题目

当子集sum大于tar的时候，也不满足

所以这里可以剪枝一下哦~

40题就难度提升了很多，题目给定数组，并且元素不能重复使用，也就是说我们还得在递归中判断当前的元素前面的父类递归有没有使用过，这就吧难度提升了很多。

这题的思路是这样的：

1. 首先我们得解决重复使用这个大问题，元素是否重复使用，肯定是两个相同的元素做判断，所以我们得排序一下，方便判断是否元素相同也就是arr[i]==arr[i-1]。
2. 其次就是既然元素相同的，如何知道它是这个数组中本来就有的元素呢，
3. 如：【1，1，1，2】，所以这里使用一个数组，专门记录当前元素的下标是否被使用。

  List<List<Integer>> ans = new ArrayList<>();

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        chak = new boolean[candidates.length];
        Arrays.sort(candidates);
        dfs(target, candidates.length, candidates, 0);
        return ans;
    }

    List<Integer> list = new ArrayList<>();
    int sum = 0;
    boolean[] chak;

    private void dfs(int k, int n, int[] arr, int p) {
        if (sum == k) {
            ans.add(new ArrayList<>(list));
            return;
        }
        for (int i = p; i < n; i++) {
            if (sum + arr[i] > k) {
                break;
            }
            if (i > 0 && arr[i] == arr[i - 1] && !chak[i - 1]) {
                continue;
            }
            chak[i] = true;
            sum += arr[i];
            list.add(arr[i]);
            dfs(k, n, arr, i + 1);
            chak[i] = false;
            sum -= arr[i];
            list.remove(list.size() - 1);
        }
    }

 此时我们的回溯就有三个了：子集集合、子集的和、还有就是元素是否被使用的数组。

!chak[i - 1]判断上一个是否使用，求false的原因是，已经被回溯重置了。