LeetCode 39,40,46,47,78,90 回溯法专题

回溯法介绍：

回溯法对任一解的生成，一般都采用逐步扩大解的方式。每前进一步，都试图在当前部分解的基础上扩大该部分解。它在问题的状态空间树中，从开始结点（根结点）出发，以深度优先搜索整个状态空间。这个开始结点成为活结点，同时也成为当前的扩展结点。在当前扩展结点处，搜索向纵深方向移至一个新结点。这个新结点成为新的活结点，并成为当前扩展结点。如果在当前扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。此时，应往回移动（回溯）至最近的活结点处，并使这个活结点成为当前扩展结点。回溯法以这种工作方式递归地在状态空间中搜索，直到找到所要求的解或解空间中已无活结点时为止。

与穷举法是类似的，都是基于试探，主要用迭代实现。

39，40题 Combination Sum I,II

题意：此题是给定一个数组，和一个target，要求数组中所有相加等于target的组合，I允许有重复数字，而II不允许。

思路和代码：把nums中的数一个个加入tempList中，用target减去每一个数，直到为0，遇到超过的，就回溯，重新选择新的数字。

class Solution {
    public List<List<Integer>> combinationSum(int[] nums, int target) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);
        backtrack(list, new ArrayList<>(), nums, target, 0);
        return list;
    }
    
    private void backtrack(List<List<Integer>> list, List<Integer> tempList, int [] nums, int remain, int start){
        //如果sum大于target使得 remain<0, 跳出迭代，去掉最后一个数
        if(remain<0) return;
        //如果等于target，加入list
        else if(remain==0){
            list.add(new ArrayList<>(tempList));
        }
        else{
            //第一次循环就进入了迭代，只有退出一次迭代的时候，循环才会继续往下走
            for(int i = start;i<nums.length;i++){
                tempList.add(nums[i]);
                backtrack(list,  tempList,  nums,  remain-nums[i],  i);
                tempList.remove(tempList.size()-1);
            }
        }
    }
}

要求不能有重复数字的只是加了重复数字判断

class Solution {
    public List<List<Integer>> combinationSum2(int[] nums, int target) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);
        backtrack(list, new ArrayList<>(), nums , target, 0);
        return list;
    }
    
    private void backtrack(List<List<Integer>> list , List<Integer> tempList, int [] nums,int remain,int start){
        if(remain<0) return;
        else if(remain==0){
            list.add(new ArrayList<>(tempList));
        }
        
        else{
            for(int i = start;i<nums.length;i++){
                if(i>start && nums[i] == nums[i-1]) continue;  //如果下一个数字还与上一个数字相同，跳过。
                tempList.add(nums[i]);
                //i变成i+1，说明每次迭代在nums中都从下一个数开始
                backtrack(list,tempList,nums,remain-nums[i],i+1);
                tempList.remove(tempList.size()-1);
            }
        }
    }
}

46,47题  Subsets I,II

题意：给一个数组，要求输出所有的组合，没有重复数字

If nums = [1,2,3], a solution is:

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

思路和代码：同样，用回溯法，像我上面说的，就跟穷举一样，代码比上个更简单，

第二题有重复数字，在for循环中加上重复判断if(i > start && nums[i]==nums[i-1]) continue; 即可。

class Solution {
    
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);
        backtrack(list,new ArrayList(),nums,0);
        return list;
    }
    
    private void backtrack(List<List<Integer>> list, List<Integer> temps, int [] nums, int start){
        list.add(new ArrayList<>(temps));
        for(int i = start;i<nums.length;i++){
            temps.add(nums[i]);
            backtrack(list,temps,nums,i+1);
            temps.remove(temps.size()-1);
        }
    }
}

78,90题   Permutations I,II

题意：此题是给定一个数组，要求所有长度相同的排列，I不允许有重复数字，而II允许有重复。

思路和代码：还是回溯，这里的条件是长度相等的。

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        
    List<List<Integer>> list = new ArrayList<>();
    backtrack(list, new ArrayList<>(), nums);
    return list;
}
private void backtrack(List<List<Integer>> list, List<Integer> tempList, int [] nums){
    //只需要长度一样的
    if(tempList.size() == nums.length){
        list.add(new ArrayList<>(tempList));
    } 
    else{
        for(int i = 0 ;i<nums.length;i++){
            //跳过同样的数字
            if(tempList.contains(nums[i])) continue;
            tempList.add(nums[i]);
            backtrack(list,tempList,nums);
            tempList.remove(tempList.size()-1);
        }
    }
}  
}

II有重复数字，所以要跳过

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        Arrays.sort(nums);
        backtrack(list,new ArrayList<>(),nums,new boolean[nums.length]);
        return list;
    }
    
    private void backtrack(List<List<Integer>> list, List<Integer> tempList, int [] nums,boolean [] used){
        if(tempList.size()==nums.length){
            list.add(new ArrayList<>(tempList));
        }
        else{
            for(int i=0;i<nums.length;i++){
               //如果i位置的被用过了，或者说当前位置的i和前一个是一样的数字，并且前一个没有被用过，那么可以跳过当前i
                if(used[i] || i>0 && nums[i] == nums[i-1] && !used[i-1] ) continue;
                used[i] = true;
                tempList.add(nums[i]);
                backtrack(list,tempList,nums,used);
                used[i]  = false;
                tempList.remove(tempList.size()-1);
            }
        }
    }
}