组合、子集、排列你们怎么这么容易重复（回溯算法题中去重总结）

在用回溯法做组合、子集和排列问题时，往往会涉及到“去重”的操作，下面总结一下。

组内去重

对于组内去重，各个问题又有所不同，下面分开讨论：

组内去重之组合问题

在组合问题中，利用startIndex可以进行组内去重，如77. 组合，部分代码如下：

组内去重代码：

		for (int i = startIndex; i <= n; i++){
            path.add(i);
            backtracking(n,k,i+1);	// 递归
            path.removeLast();	    // 回溯 
        }

可以看出，组内去重是利用递归传递 i + 1，使得组内下一个元素一定不会重复，但是，当遇到所给数组中已经存在重复元素时，就要涉及到组间去重。这部分下面将会介绍。而有些题中，允许组内元素可以重复，这里在递归传入参数时，就可以传 i 了，所以总结：组内的元素怎么样，是通过控制外层for循环与递归时传递的参数来控制的。
而子集问题与组合类似，单层递归部分基本差不多。

组内去重之排列问题

排列问题的特殊在于，子集数与父集数相同，每一个都必须排列，组内不能重复，但是在递归时，for循环起始从0开始（为了让每个位置都可以选所有的数字），是不需要startIndex的，而为了确保不重复，这里就巧妙的用了哈希法的思想，把使用过的元素存入一个哈希表中（这里由于可选数据小，可以用数组作为哈希表）记录下来，下次加入元素前，判断一下是否使用过就行了。

组内去重代码：

		for(int i = 0; i < nums.length; i++) {
            // 去重操作
            if(!temp.isEmpty() && table[nums[i] + 10]) {
                continue;
            }
            temp.add(nums[i]);
            table[nums[i] + 10] = true;    // 设置哈希表，使用过的元素记录
            backtracking(nums);
            temp.remove(temp.size() - 1);  // 回溯
            table[nums[i] + 10] = false;   // 回溯之后，使用过的记录也清空
        }

组间去重

涉及到组间去重的问题，往往题目所给数据已经存在重复元素，而答案要求不能有相同的组合，如：40. 组合总和 II、90. 子集 II、47. 全排列 II等等，下面分别给出这几个问题关键的代码：

组间去重之组合问题

		for(int i = startIndex; i < candidates.length; i++) {
            if(target - candidates[i] < 0) {    // 剪枝，有了这一步，在外面的循环就可以少一个退出条件了，因为达到退出条件的，只有符合条件的结果集了
                continue;
            }
            target -= candidates[i];
            temp.add(candidates[i]);
            backtracking(candidates, target, i + 1);
            target += candidates[i];
            temp.remove(temp.size() - 1);
            // 回溯之后，为了保证下一次取的数字不重复，一直移动i，便能确保去重，注意要先控制i + 1小于数组大小，否则会出现空指针异常
            while(i + 1< candidates.length && candidates[i + 1] ==candidates[i]) {
                i++;
            }
        }

组间去重之子集问题

		for(int i = startIndex; i < nums.length; i++){
            temp.add(nums[i]);
            backtracking(nums, i + 1);
            temp.remove(temp.size() - 1);
            while(i + 1 < nums.length && nums[i + 1] == nums[i]) {// 组间去重操作
                i++;
            }
        }

组间去重之排列问题

		for(int i = 0; i < nums.length; i++) {
            if(used[i]) {
                continue;
            }
            temp.add(nums[i]);
            used[i] = true;
            backtracking(nums, used);
            temp.remove(temp.size() - 1);
            used[i] = false;
            while(i + 1 < nums.length && nums[i +1] == nums[i]) {
                i++;
            }
        }

可以看出，对于组间要去重的操作，关键在于回溯时加上这段代码：

	while(i + 1 < nums.length && nums[i +1] == nums[i]) {
                i++;
            }

这就是判断下一次循环时，是否用了已经找到满足条件的组合，需要跳过。

特殊情况（491. 非递减子序列）

但是有些题目，虽然所给数字有重复的，但是组合中可以出现重复元素，这时千万别无脑用模板，看清楚题目再下手，如下面这题：
491. 非递减子序列
给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]
示例 2：

输入：nums = [4,4,3,2,1]
输出：[[4,4]]
代码：

class Solution {
    List<Integer> temp = new ArrayList<>();
    List<List<Integer>> result = new ArrayList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backtracking(nums, 0);
        return result;
    }
    public void backtracking(int[] nums, int startIndex) {
        if(temp.size() >= 2) {
            result.add(new ArrayList<>(temp));
        }
        Set<Integer> set = new HashSet<>();
        for(int i = startIndex; i < nums.length; i++) {
            // 解决递增以及重复的问题
            if(!temp.isEmpty() && (nums[i] < temp.get(temp.size() - 1)) || set.contains(nums[i])) {
                continue;
            }
            temp.add(nums[i]);
            set.add(nums[i]);
            backtracking(nums, i + 1);
            temp.remove(temp.size() - 1);
        }
    }
}

今天的另一道打卡题：

46.全排列

没什么特别，就是理解排列和组合的区别就行，在于for循环的设置。

class Solution {
    List<Integer> temp = new ArrayList<>();
    List<List<Integer>> result = new ArrayList<>();
    boolean[] table = new boolean[21];
    public List<List<Integer>> permute(int[] nums) {
        backtracking(nums);
        return result;
    }
    public void backtracking(int[] nums) {
        if(temp.size() == nums.length) {
            result.add(new ArrayList<>(temp));
            return;
        }
        
        for(int i = 0; i < nums.length; i++) {
            // 去重操作
            if(!temp.isEmpty() && table[nums[i] + 10]) {
                continue;
            }
            temp.add(nums[i]);
            table[nums[i] + 10] = true;    // 设置哈希表，使用过的元素记录
            backtracking(nums);
            temp.remove(temp.size() - 1);  // 回溯
            table[nums[i] + 10] = false;   // 回溯之后，使用过的记录也清空
        }
    }
}