回溯算法总结

最近刷题刷到回溯算法，刷的头大，官方的题解更是看的头大。背很快又忘了，今天总结一下几种回溯解决的问题。

下面的几道题为了更好的记忆，都是用一套模板套出来的，并不是最简洁的代码。

细节1：

递归函数中，再次递归时，可以重复元素的从i开始，不能重复的从i+1开始。

LeetCode78

求不含重复数据的子集，子集不能是重复的。

比如{1,2,3}，{1,2}{2,1} 就是重复的。

1.子集问题，index去保证递归的方向是向下的。

/K表示有多少个元素需要装入集合中
for(int k=1; k<=nums.length; k++){
    dfs(nums, 0, k, new ArrayList<>());
}
void dfs(int[] nums, int index, int k, List<Integer> temp){
        //递归结束条件，表示集合中已经装了k个元素
        if(k == 0){
            ans.add(new ArrayList<>(temp));
            return;
        }
        for(int i = index; i<nums.length; i++){
            temp.add(nums[i]);
            //递归装数据
            //下一个数据是i+1，已经装了一个数据，所以k=k-1
            dfs(nums, i+1, k-1,temp);
            //回溯
            temp.remove(temp.size()-1);
        }
    }

LeetCode77

给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合

1.子集问题

2.给定k个元素需要装入集合中

//index需要从1开始
dfs(n, 1, k, new ArrayList<>());
void dfs(int n, int index, int k, ArrayList<Integer> temp) {
        if(k == 0){
            ans.add(new ArrayList<>(temp));
            return;
        }
        //结束需要=n
        for(int i=index; i<=n; i++){
            temp.add(i);
            dfs(n, i+1, k-1, temp);
            temp.remove(temp.size()-1);
        }
    }

Leetcode39

无重复元素的正整数数组 candidates，求和是target的集合。数组中元素可以重复使用，只要有一个元素不同就算一种结果。

1.k可以将数组排序后，按照最小的元素一直装，那么k最大是target/nums[0]

2.可以重复，递归中从i开始。

Arrays.sort(candidates);
int n = target/candidates[0];

for(int k = 1; k <= n; k++){
   dfs(candidates, 0, k, new ArrayList<>(), target);
}

if(k == 0){
  int sum = temp.stream().mapToInt(Integer::intValue).sum();
  if(sum == target){
  ans.add(new ArrayList<>(temp));
  }
  return;
}
for(int i=index; i<candidates.length; i++){
    temp.add(candidates[i]);
    //可以重复选择，从i开始，而不是i+1
    dfs(candidates, i, k-1, temp, target);
    temp.remove(temp.size()-1);
}

LeetCode40

给定一个可能有重复数字的整数数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的每个数字在每个组合中只能使用一次，解集不能包含重复的组合。 

1.可以包含重复元素，但一个元素不能多次使用。不能包含重复的组合，需要去重。

       a. 将所有可能结果求出后，排序、去重，超时。

       b. 只能在列举集合过程中去重

          （1）sum > target  结束

          （2）一个结果中重复使用了已经使用过的元素

第二点贴出大佬的方法，理解不透彻先背吧~~

最后代码：

int n = candidates.length;
        boolean[] flag = new boolean[candidates.length];
        Arrays.sort(candidates);
        for(int k=1; k<=n; k++){
            dfs(candidates,0,k,new ArrayList<Integer>(),target, flag);
        }
if(k == 0){
            //int sum = temp.stream().mapToInt(Integer::intValue).sum();
            if(sum == target){
                // 排序 去重 超时！
                //List<Integer> list = new ArrayList<>(temp);
               // Collections.sort(list);
                //if(!ans.contains(list)){
                    ans.add(new ArrayList<>(temp));
                //}
            }
        }
        for(int i=index; i<candidates.length&&sum+candidates[i]<=target; i++){
            if(i>0 && candidates[i] == candidates[i-1] && flag[i-1]==false){
                continue;
            }
            temp.add(candidates[i]);
            sum+=candidates[i];
            flag[i] = true;
            dfs(candidates, i+1,k-1, temp, target, flag);
            sum-=temp.get(temp.size()-1);
            flag[i] = false;
            temp.remove(temp.size()-1);
        }

 LeetCode46

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

参考40题，对排列去重

boolean[] flag = new boolean[nums.length];
        Arrays.sort(nums);
        dfs(nums,0, nums.length, new ArrayList<Integer>(),flag);
if(k == 0){
            ans.add(new ArrayList<>(temp));
            return;
        }
        for(int i=0; i<nums.length; i++){
            //一个答案就是一个树枝。
            if(flag[i]){
                continue;
            }
            temp.add(nums[i]);
            flag[i] = true;
            //不能重复index = i+1
            dfs(nums, i+1,k-1, temp, flag);
            flag[i] = false;
            temp.remove(temp.size()-1);
        }

LeetCode47

给定一个可包含重复数字的整数集合 nums ，按任意顺序 返回它所有不重复的全排列。

1.树枝和树层都需要去重

boolean[] flag = new boolean[nums.length];
        Arrays.sort(nums);
        dfs(nums,0, nums.length, new ArrayList<Integer>(),flag);
if(k == 0){
            ans.add(new ArrayList<>(temp));
            return;
        }
        for(int i=0; i<nums.length; i++){
            //树枝去重
            if(flag[i]){
                continue;
            }
            //树层去重
            if(i>0 && nums[i] == nums[i-1] && flag[i-1] == false){
                continue;
            }
            temp.add(nums[i]);
            flag[i] = true;
            //不能重复index = i+1
            dfs(nums, i+1,k-1, temp, flag);
            flag[i] = false;
            temp.remove(temp.size()-1);
        }