【LeetCode】参照LeetCode上的Solution总结：同类解法

LeetCode上看到的一类提醒的一种解法总结：
A general approach to backtracking questions in Java (Subsets, Permutations, Combination Sum, Palindrome Partioning)
原作者是用Java实现的，这里我因为试验，把第一个改成了C++版。
虽然这种解法不见得效率很高，但是不失为在没有解决思路的情况下的一种简明清晰的思路，并且实现起来花时间比较少。

思路

总结起来就是说，使用一个tempList来构造每一个符合条件的数组list，每次向list中添加一个符合条件的单元素，然后在这种情况下，继续遍历寻找每一个符合条件的下一个单元素。结合代码来看可能更为清楚。

Permutation代码（C++）

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> result;
        vector<int> temp;
        backtrack(result, temp, nums);
        return result;
    }

    void backtrack(vector<vector<int>>& result, vector<int>& temp, vector<int>& nums) {
        if (temp.size() == nums.size()) {
            result.push_back(temp);
        } else {
            //遍历整个nums元素备选集，寻找符合标准的结果。
            for (int i = 0; i < nums.size(); i++) {
                if (find(temp.begin(), temp.end(), nums[i]) != temp.end()) {
                    continue;
                }
                temp.push_back(nums[i]);//假设nums[i]符合标准
                backtrack(result, temp, nums);//寻找在nums[i]符合标准的假定下的下一个结果，如果找到，则已经加入到result结果集中
                temp.erase(temp.end()-1);//清除nums[i]，并继续nums[i+1]这个元素的计算判定。
            }
        }

    }
};

Permutation代码（Java）

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

Permutations II 代码（Java）

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代码 (Java)

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

Combination Sum II代码 (Java)

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);
            tempList.remove(tempList.size() - 1); 
        }
    }
} 

Subsets（C++）

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> result;
        vector<int> tempList;
        sort(nums.begin(), nums.end());

        helper(result, nums, tempList, 0);
        return result;
    }

    void helper(vector<vector<int>>& result, vector<int>& nums, vector<int>& tempList, int start) {
        result.push_back(tempList);
        for (int i = start; i < nums.size(); i++) {
            tempList.push_back(nums[i]);
            helper(result, nums, tempList, i + 1);
            tempList.erase(tempList.end()-1);
        }
    }
};

Combinations(C++)

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        vector<vector<int>> result;
        vector<int> tmp;

        helper(result, tmp, 1, n, k);

        return result;
    }

    void helper(vector<vector<int>>& result, vector<int>& tmp, int start, int n, int k) {
        if (k == 0) {
            result.push_back(tmp);
            return;
        }

        for (int i = start; i <= n; i++) {
            tmp.push_back(i);
            helper(result, tmp, i+1, n, k-1);
            tmp.erase(tmp.end()-1);
        }
    }
};