代码随想录刷题 Day 29

491. Non-decreasing Subsequences

此题也是要做去重操作，另外由于要输出递增的数组，所以不能排序，因此用了一个set来存之前遍历过的数据

class Solution {
public:
    //要注意这个题不能排序，不然的话输出的所有情况都是递增的，所以用了一个map来存遍历过得数
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex){
        if(path.size()>1){
            result.push_back(path);//这里不需要return,加了也没问题 if(startindex== nums.size()-1) return, 但是这个逻辑在下面的for循环中已经有了
        }
        unordered_set<int> uset;
        for(int i=startIndex; i<nums.size();i++){
            if(((path.empty()!=true) && nums[i] < path.back()) || uset.find(nums[i])!=uset.end())
            //path.back() 是读出来path里面的最右边的那个元素然后和下一个要取的元素对比大小；path.empty()返回的是true and false; 如果写成！=0会报错
            //uset.find(nums[i]!=uset.end()) 这行是判断本层这个数有没有被用过一样的数字；
            {continue;}
            // continoue是跳出本层循环； 可以继续i++下层循环； 如果break就直接跳出for；
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(nums,i+1);
            path.pop_back();

        }
    }

    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return result;
    }
};

46. Permutations

这道题就是排列的情况，另外注意由于所有的数字只能用一次，所以需要用一个used数组记录下那个数组有没有用过。 这个used数组要作为递归函数的参数使用，一开始我没有把used写进参数就不能通过。

class Solution {
public:
    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);
                path.pop_back();
                used[i] =false;
            
        }
    }

    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        backtracking(nums,used);
        return result;
    }
};

47. Permutations II

如果nums[i] == nums[i - 1] && used[i - 1] == false, 说明这时候代码从上一个分支回溯回来了，回溯过程中把used[i-1] 恢复成了false， 此时做的是树层上去重；

如果nums[i] == nums[i - 1] && used[i - 1] == true,此时是树脂上去重，这个题两种都可以；

class Solution {
public:
    
    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) //因为操作了i-1所以要确保i>0
            {continue;}

            if(used[i] == false){
                path.push_back(nums[i]);
                used[i] =true;
                backtracking(nums,used);
                path.pop_back();
                used[i] =false;
            } 
        }
    }

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