LeetCode回溯问题合集(general 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> tempList, int [] nums, int start){    list.add(new ArrayList<>(tempList));    for(int i = start; i < nums.length; i++){        tempList.add(nums[i]);             backtrack(list, tempList, nums, i + 1);        tempList.remove(tempList.size() - 1);      }}

对于带有重复元素的子集问题，也是同样的思路，不同之处在于我们需要过滤掉重复的集合。

首先对数组进行排序，来方便后续过滤重复时候的操作。

接着来分析，按照上边的思路，什么时候会出现重复的集合：对于单个元素集合，我们只需要其出现一次，因此有了skip duplicates的操作；那么，对于两个元素的集合是否也是如此呢？答案是肯定的，因为后续的递归可以看作是没有第一个元素以后的子问题。

public List<List<Integer>> subsetsWithDup(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> tempList, int [] nums, int start){    list.add(new ArrayList<>(tempList));    for(int i = start; i < nums.length; i++){        if(i > start && nums[i] == nums[i-1]) continue; // skip duplicates        tempList.add(nums[i]);        backtrack(list, tempList, nums, i + 1);        tempList.remove(tempList.size() - 1);    }} 

对于全排列问题，同理，在没有重复元素时，第一层递归枚举所有长度为1的templist，第二层递归再往上加没有用过的元素。但是。。。那个每次检查是否重复使用的操作，貌似很费时间啊。

public List<List<Integer>> permute(int[] nums) {   List<List<Integer>> list = new ArrayList<>();   // Arrays.sort(nums); // not necessary   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; // element already exists, skip         tempList.add(nums[i]);         backtrack(list, tempList, nums);         tempList.remove(tempList.size() - 1);      }   }} 

如果有重复元素时，该怎么办呢？

还是先分析，上边那个做法为什么不可行呢。因为数据有重复，不可能使用contains查重了。如何判断重复数据是否加入templist呢？

对于重复数据连在一起的情况，我们只需要其在最后结果中出现一次，如何保证其只出现一次呢，就是在每次递归中保证templist中的数据次序是唯一的。因此需要一个used数组来指示这个次序，只有在前一个数used情况下，后一个重复数才可能接在其后。

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++){            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);        }    }}

还有Combination Sum未完待续。。。

续上。

Combination Sum问题是指从某一数组中找出某几个数使其和为定值Target。

第一种情况是可以重复利用元素，这种情况最为简单，套用模板即可解决。

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){    if(remain < 0) return;    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); // not i + 1 because we can reuse same elements            tempList.remove(tempList.size() - 1);        }    }}

第二种情况稍微复杂一点，即不可使用重复元素。继续沿用上边的思路，我们只需要在templist加入元素时，保证不加入重复元素即可。为了方便跳过重复元素，也需要首先将原数组进行排序。

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; // skip duplicates            tempList.add(nums[i]);            backtrack(list, tempList, nums, remain - nums[i], i + 1); //i+1很关键            tempList.remove(tempList.size() - 1);         }    }} 

另外的几道Combination Sum的题目与上边两种大同小异，都可以沿用这种思路进行求解。