12.10 log

46.全排列

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums,unordered_set<int> uset){
        if(path.size()==nums.size()){
            result.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if(uset.find(nums[i])!=uset.end()) continue;
            path.push_back(nums[i]);
            uset.insert(nums[i]);
            backtracking(nums,uset);
            path.pop_back();
            uset.erase(nums[i]);
        }
        return;
    }
public:
    vector<vector<int>> permute(vector<int>& nums) {
        path.clear();
        result.clear();
        unordered_set<int> uset;
        backtracking(nums,uset);
        return result;
    } 
};

这道题我是用set容器来记录是否元素是否用过，其实也可以用bool类型的vector容器来记录

代码如下：

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums,vector<bool>& used){
        if(path.size()==nums.size()){
            result.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if(used[i]==true) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,used);
            path.pop_back();
            used[i]=false;
        }
        return;
    }
public:
    vector<vector<int>> permute(vector<int>& nums) {
        path.clear();
        result.clear();
        vector<bool> used(nums.size(),false);
        backtracking(nums,used);
        return result;
    } 
};

递归参数为传入的数组，由于记录是否元素是否用过的used数组，无返回值；递归的终止条件为如果path长度与传入数组长度相等时，result记录path并返回；递归的单层逻辑为用for循环横向遍历，进入循环先判断used[i]是否为true，如果为true就是之前用过了，要continue掉，如果没有用过，path记录该nums[i]，used[i]令为true，视为用过，然后进入下一层递归，然后再回溯，used[i]变为false，path在pop掉。

47.全排列 II 

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums,vector<bool>& used){
        if(path.size()==nums.size()){
            result.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if(used[i]==true||i>0&&nums[i]==nums[i-1]&&used[i-1]==false) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,used);
            path.pop_back();
            used[i]=false;
        }
        return;
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        path.clear();
         result.clear();
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        backtracking(nums,used);
        return result;
    }
};

全排列事实上就是树枝去重，而这题其实就是树枝和树层去重的结合。

递归的参数为传入的数组，标记元素是否使用的used数组，返回值为空；递归的终止条件为当path长度和数组长度相等时返回；单层递归逻辑为用for循环横向遍历，进入循环判断，是否是树枝重复或者树层重复，两者都要continue，如果符合要求path记录，used数组令为true，进入递归，然后回溯。不要忘记，本题树层去重是要给数组提前排序的。