代码随想录刷题打卡day28

1.491. 递增子序列这道题的陷阱在于不能进行排序，要找自增的子序列。一层中出现过的数字就不能再出现了（层不重复），而不用管树枝，且我们用的unordered_set在每一层都重新定义，因此不用回溯。代码随想录解析，此外这道题和90.子集II又非常地像，之前用的used一维数组判断层和树枝，因此需要回溯。

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);
        }
        //每层都要重新定义一个set,只判断每层是否有重复的元素，因此下面不用回溯
        unordered_set<int> set;
        for(int i=startIndex;i<nums.size();i++){
            //当前元素小于上一个元素或者该元素已经出现过
            if((!path.empty()&&nums[i]<path.back())||set.find(nums[i])!=set.end()){
                continue;
            }
            path.push_back(nums[i]);
            set.insert(nums[i]);
            backtracking(nums,1+i);
            path.pop_back();

        }

    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums,0);
        return result;
    }
};

46. 全排列排列和组合的区别就在于排列结果之间可以元素相同，只要元素位置不同即可。因此需要一个used数组判断当前的元素是否已经用过，而不能用startIndex。举个栗子，当我们第一次从[0 1 2]中选了1，此时used[0 1 0],在进入backtracking后（树枝）nums[i]重新开始从nums[0-2]遍历，那么nums[0]的used[0]=false表示没用，加入到path,而nums[1]的uesd[1]=true,表示path中已经有1了。代码随想录解析

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

47. 全排列 II 这道题的去重逻辑和之前的78.子集是一样的，唯一的不同在于，全排列的for循环是从0开始，（那么下一层也会遍历到自身）因此要多一层判断，判断当前的数字是否被用过 if(used[i]==false)，没有的话才进行下面的操作。而子集那道题是for循环从startIndex开始，当前的开始的数字肯定是没用过的。

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;
        }
        //这里是从0开始遍历，因此会遍历到自身，所以不仅要判断是否重复，还要判断是否取到自身，这就是组合和排列的不同。排列都是从0开始遍历，因为顺序不同，结果也不一样。
        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){
                path.push_back(nums[i]);
                used[i]=true;
                backtracking(nums,used);
                used[i]=false;
                path.pop_back();
            }

        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        backtracking(nums,used);
        return result;
    }
};