回朔法里的去重问题

回朔法里的去重问题主要分为横向去重和纵向去重

• 横向去重
  1、数组是不可以进行排序的
  力扣491：递增子序列
  给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。
  
  这里很明显，是横向去重（本层内是不可以重复的），纵向是可以重复的。但是注意这里数组是不可以进行排序的。因此可以用一个set去标记本层内是否可以重复。

import java.util.*;

public class h491_findSubsequences {

    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    public void backtrace(int[] nums, int startIndex){
         if(path.size()>=2){
             result.add(new ArrayList<>(path));
         }
         Set set = new HashSet();  // 记录本层是否有相同元素，针对的是无序的数组
         for(int i=startIndex; i<nums.length; i++){
             if((!path.isEmpty()&&nums[i]<path.get(path.size()-1))||set.contains(nums[i]))
                 continue;
             set.add(nums[i]);
             path.add(nums[i]);
             backtrace(nums,i+1);
             path.remove(path.size()-1);
         }
    }

    public List<List<Integer>> findSubsequences(int[] nums) {
        backtrace(nums,0);
        return result;
    }
}

2、数组可以进行排序的
力扣40题组合总数二
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
说明： 所有数字（包括目标数）都是正整数。 解集不能包含重复的组合。

示例 1: 输入: candidates = [10,1,2,7,6,1,5], target = 8, 所求解集为: [ [1, 7], [1, 2, 5], [2, 6], [1, 1, 6] ]

示例 2: 输入: candidates = [2,5,2,1,2], target = 5, 所求解集为: [ [1,2,2], [5] ]

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class h40_combinationSum2 {

    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    public void backtrace(int[] candidates, int target, int sum, int startIndex){
        if(sum==target){
            if(!result.contains(new ArrayList<>(path)))
                result.add(new ArrayList<>(path));
            return;
        }
        for(int i=startIndex;i<candidates.length;i++){
            if(i!=startIndex&&candidates[i]==candidates[i-1])
                continue;
            sum+=candidates[i];
            if(sum>target)
                break;
            path.add(candidates[i]);
            backtrace(candidates,target,sum,i+1);
            sum-=candidates[i];
            path.remove(path.size()-1);
        }
    }

    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        backtrace(candidates,target,0,0);
        return result;
    }

    public static void main(String[] args) {
        int[] candidates = {10,1,2,7,6,1,5};

        h40_combinationSum2  h40 = new h40_combinationSum2();
        System.out.println(h40.combinationSum2(candidates,8));
    }
}

当然有序的用set也是可以的，只是每次都会新建一个set，比较耗空间和时间

• 纵向去重
  纵向去重较为简单，只需要使用一个数组去标记即可

力扣46题全排列

import java.util.ArrayList;
import java.util.List;

public class h46_permute {

    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();


    public void backtrace(int[] nums, boolean[] used){
        if(path.size()>=nums.length){
            result.add(new ArrayList<>(path));
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(used[i])
                continue;
            path.add(nums[i]);
            used[i]=true;
            backtrace(nums,used);
            path.remove(path.size()-1);
            used[i]=false;

        }
    }

    public List<List<Integer>> permute(int[] nums) {
          boolean[] used = new boolean[nums.length];
          backtrace(nums,used);
          return result;
    }

    public static void main(String[] args) {
        int[] nums = {1,2,3};
        boolean[] used = new boolean[nums.length];
        h46_permute h46 = new h46_permute();
        System.out.println(h46.permute(nums));
    }
}

• 横向去重加纵向去重
  力扣47全排列2
  

import java.util.*;

public class h47_permuteUnique {

    List<List<Integer>> result = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    public void backtrace(int[] nums,boolean[] used){
        if(path.size()==nums.length){
            result.add(new ArrayList<>(path));
            return;
        }
        Set<Integer> set = new HashSet<>();  // set用于在本层上去重，used在深度上去重
        for(int i=0;i<nums.length;i++){
            if(set.contains(nums[i])||used[i])   // 如果在本层上有重复或者在深度上有重复，则跳过
                continue;
            used[i]=true;
            set.add(nums[i]);
            path.add(nums[i]);
            backtrace(nums,used);
            used[i]=false;
            path.remove(path.size()-1);
        }
    }



    public List<List<Integer>> permuteUnique(int[] nums) {
        boolean[] used = new boolean[nums.length];
        backtrace(nums,used);
        return result;
    }
}