代码随想录算法训练营 day 25 | Leetcode 491 46 47

Leetcode 491 非递减子序列

这里要注意不能对序列排序，使用一个unordered_set对数层天然去重。

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> uset;
        for(int i = startIndex; i < nums.size(); i++){
            if(uset.find(nums[i]) != uset.end() || (!path.empty() && nums[i] < path.back())){
                continue;
            }
            uset.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;
    }
};

Leetcode 46 全排列

很简单，需要使用一个used来记录是否访问过

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);
            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;
    }
};

Leetcode 47 全排列Ⅱ

46和491的结合，由于集合中有重复元素，但是结果中不能重复，因此既需要用一个unordered_set对树层去重，有需要用used来跳过已使用的元素。

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;
        }
        unordered_set<int> uset;
        for(int i = 0; i < nums.size(); i++){
            if(uset.find(nums[i]) != uset.end() || used[i] == true){
                continue;
            }
            uset.insert(nums[i]);
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums, used);
            used[i] = false;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return result;
    }
};