回溯去重总结

1.不用数组

力扣：40. 组合总和 II

class Solution {
    List<List<Integer>> lists = new ArrayList();
    List<Integer> list = new ArrayList();
    int sum = 0;
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtrace(candidates, target, 0);
        return lists;
    }

      public void backtrace(int[] candidates, int target, int index){  
        if(sum > target) return;    
        if(sum == target) {
            lists.add(new ArrayList(list));
            return;
        }

        for(int i=index; i<candidates.length; i++){
            if(i>index && candidates[i]==candidates[i-1]) continue;  //去重高手， i==index时是重复元素的第一个，不用去掉
            list.add(candidates[i]);
            sum = sum + candidates[i];
            backtrace(candidates, target, i+1);
            sum = sum - candidates[i];
            list.remove(list.size()-1);
        }
    }
}

力扣90. 子集 II

class Solution {
    List<List<Integer>> lists = new ArrayList();
    LinkedList<Integer> list = new LinkedList();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        backtrace(nums, 0);
        return lists;
    }

    public void backtrace(int[] nums, int index){
        lists.add(new ArrayList(list));
        if(nums.length == index) return;
        
        for(int i=index; i<nums.length; i++){
            if(i!=index && nums[i]==nums[i-1]) continue;
            list.add(nums[i]);
            backtrace(nums, i+1);
            list.removeLast();
        }
    }
}

2.用一个visited全局数组

visited数组用来标记元素是否访问过，记录元素下标
for循环从0开始
47. 全排列 II

class Solution {
    List<List<Integer>> lists = new ArrayList();
    LinkedList<Integer> list = new LinkedList();
    boolean[] visited = new boolean[30];                //标记该元素有没有访问过，记录下标
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        backtrace(nums);
        return lists;
    }
     public void backtrace(int[] nums){
        if(nums.length == list.size()){
            lists.add(new ArrayList(list));
            return;
        }
        // visited[i - 1] == true，说明同一树支nums[i - 1]使用过
        // visited[i - 1] == false，说明同一树层nums[i - 1]使用过
        for(int i=0; i<nums.length; i++){
            if(i>0 && nums[i]==nums[i-1] && visited[i-1]==false) continue;
            if(visited[i] == false){        //该点没访问过
                visited[i] = true;
                list.add(nums[i]);
                backtrace(nums);
                visited[i] = false;
                list.removeLast();
            }
        }
    }
}

3.用一个局部数组

数组记录这个数在同层是否出现过
491. 递增子序列

class Solution {
    List<List<Integer>> lists = new ArrayList();
    LinkedList<Integer> list = new LinkedList();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backtrace(nums, 0);
        return lists;
    }
    public void backtrace(int[] nums, int index){
        if(list.size() >= 2) lists.add(new ArrayList(list));
        
        int[] visited = new int[202];           //记录这个数在同层是否出现过
        for(int i=index; i<nums.length; i++){
            if(visited[nums[i] + 100]==1) continue;    //该元素在同层出现过
            if(list.size()!=0 && nums[i] < list.peekLast()) continue;         //该元素小于list序列的最后一个元素，不递增了
            visited[nums[i] + 100]=1;
            list.add(nums[i]);
            backtrace(nums, i+1);
            list.removeLast();
        }
    }
}