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&g
b19e
t; 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);
}
}
}
}