力扣第24天----第491题、第46题、第47题

力扣第24天----第491题、第46题、第47题

一、第491题–递增子序列

​ 这个题，由于不能排序，不能使用全局变量进行监控，要在函数内部创建监控变量(unordered_set myset)，进行判断。这样，每次递归时都会创建一个新的监控变量，这个监控变量，监控这一层的情况。如果使用全局的变量，那么会监控整个一棵树的情况。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;

    void backtracing(vector<int>& nums, int startindex){
        if (path.size() >= 2) result.push_back(path);
        unordered_set<int> myset;             //在内部进行判断
        for (int i = startindex; i < nums.size(); i++){
            if (!path.empty() && nums[i] < path.back() || myset.find(nums[i]) != myset.end()){
              //  cout << nums[i] << endl;
                continue;
            } 
            myset.insert(nums[i]);
            path.push_back(nums[i]);
            backtracing(nums, i+1);
            path.pop_back();
        }
    }

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

二、第46题–全排列

​ 排列问题，不需要startindex，每次都是从头遍历，从0开始即可。这里元素不能重复使用，所以通过vector used(nums.size(), false)，记录每个元素是否被使用，然后遇到已经被使用过的，跳过即可。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;

    void backtracing(vector<int>& nums, vector<bool>& used){
        if (path.size() >= nums.size()) result.push_back(path);
        for(int i = 0; i < nums.size(); i++){
            if(used[i] == true) continue;
            path.push_back(nums[i]);
            used[i] = true;
            backtracing(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }

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

三、第47题–全排列 II

​ 每一层内，不能使用重复的元素，通过used及nums进行把控；而且要求排列，不能使用通过startindex，只能通过used记录每个元素是否被使用，然后遇到已经被使用过的，跳过即可。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;

    void backtracing(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-1] == nums[i] && used[i-1] == false) continue;  //树层去重
            if(used[i] == true) continue;                                     //排序，遇到重复的跳过。
            path.push_back(nums[i]);
            used[i] = true;
            backtracing(nums, used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        vector<bool> used(nums.size(), false);
        backtracing(nums, used);
        return result;
    }
};