leetcode（力扣）491. 递增子序列||46. 全排列||47. 全排列 II

去重一定要对原始元素进行排序，全排列每层都是从0开始搜索，不需要startIndex，去重需要使用used数组记录path里放了哪些元素。

used[i - 1] == true，说明同一树枝nums[i - 1]使用过
used[i - 1] == false，说明同一树层nums[i - 1]使用过

491. 递增子序列

class Solution {
private:
        vector<vector<int>> result;
        vector<int> path;
        void backtracking(vector<int>& nums,int startIndex){
            if(path.size()>1){
                result.push_back(path);
            }
            unordered_set<int> unset;
            for(int i=startIndex;i<nums.size();i++){
                if(!path.empty()&&path.back()>nums[i]||unset.find(nums[i])!=unset.end()){
                    continue;
                }
                unset.insert(nums[i]);
                path.push_back(nums[i]);
                backtracking(nums,i+1);
                path.pop_back();
            }
        }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
          backtracking(nums,0);
          return result;
    }
};

46. 全排列

class Solution {
private:
        vector<vector<int>> result;
        vector<int> path;
        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);
                used[i]=false;
                path.pop_back();
            }
        }
public:
    vector<vector<int>> permute(vector<int>& nums) {
       vector<bool> used(nums.size(),false);
       backtracking(nums,used);

       return result;
    }
};

47. 全排列 II

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