代码随想录算法训练营第三十一天|491.递增子序列 、46.全排列、47.全排列 II

代码随想录算法训练营第三十一天

491.递增子序列

题目链接：491.递增子序列

class Solution {
public:
    vector<int> result;
    vector<vector<int>> results;
    void backtracking(vector<int>& nums, int startIndex) {
        unordered_set<int> uset;//创建一个set用于记录已经使用过的元素
        if (result.size() >= 2)
            results.push_back(result);
        if (startIndex > nums.size())
            return;
        for (int i = startIndex; i < nums.size(); i++) {
            if (!result.empty() && nums[i] < result.back())//保证结果是递增的
                continue;
            if (uset.find(nums[i])!=uset.end())continue;//横向去去重
            result.push_back(nums[i]);
            uset.insert(nums[i]);//记录已使用过的元素
            backtracking(nums, i + 1);//递归
            result.pop_back();//回溯
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums, 0);
        return results;
    }
};

---

46.全排列

题目链接：46.全排列

class Solution {
public:
    vector<int> result;
    vector<vector<int>> results;
    unordered_set<int> uset;//用一个全局的集合记录使用过的元素

    void backtracking(vector<int>& num){
        if(result.size()==num.size()){
            results.push_back(result);
            return;
        }
        for(int i =0;i<num.size();i++){
            if(uset.find(num[i])!=uset.end())continue;//当前元素已经使用过了就不再用了
            result.push_back(num[i]);
            uset.insert(num[i]);//没用过的元素放到记录中
            backtracking(num);//递归
            result.pop_back();//回溯
            uset.erase(num[i]);//回溯将该元素重新置为未使用
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        backtracking(nums);
        return results;
    }
};

---

47.全排列 II

题目链接：47.全排列 II

class Solution {
public:
    vector<int> result;
    vector<vector<int>> results;
    void backtracking(vector<int>& nums,vector<bool> used){
        if(result.size()==nums.size()){
            results.push_back(result);
            return;
        }
        for(int i = 0;i<nums.size();i++){
            if(used[i])continue;
            if(i>0&&nums[i-1]==nums[i]&&used[i-1])continue;//排过序的如果前一个元素和这个元素相等，而且前一个元素用过，就跳过本次循环
            result.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,used);
            result.pop_back();
            used[i]=false;
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used(nums.size());
        sort(nums.begin(),nums.end());
        backtracking(nums,used);
        return results;
    }
};

---