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

最新推荐文章于 2024-09-26 00:03:11 发布

JCGKS

最新推荐文章于 2024-09-26 00:03:11 发布

阅读量71

点赞数

分类专栏：算法与数据结构文章标签：算法 leetcode 数据结构 c++

本文链接：https://blog.csdn.net/weixin_46290302/article/details/131088047

版权

算法与数据结构专栏收录该内容

57 篇文章 0 订阅

订阅专栏

491.递增子序列

链接：LeetCode491.递增子序列

class Solution {
public:
    //有前提条件的组合
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return ans;
    }
private:
    vector<vector<int>> ans;
    vector<int> res;
    void backtracking(const vector<int>&nums,int st){
        if(res.size()>=2) {
            ans.emplace_back(res);
        }

        int used[201] = {0};//同一层去重
        for(int i=st;i<nums.size();++i){
            //去重
            if(used[nums[i]+100]) continue;
            if(res.empty() || nums[i]>=res.back()) {
                used[nums[i]+100] =1;
                res.emplace_back(nums[i]);
                backtracking(nums,i+1);
                res.pop_back();
            }else continue;
        }
    }
};

本题求的就是自增子序列，所以不能对原数组进行排序，那也就不能采用先排序后去重的方式进行去重了。
本题的去重关键“同一个父节点下的同层上使用过的元素不能再次使用”，可以在每一层设置一个辅助集合，将使用过的数值加入到该集合中，防止被二次使用。由于nums中数值的范围在[-100,100]之间，可以使用数组来代替集合。

46.全排列

链接：LeetCode46.全排列

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        backtracking(nums,used);
        return ans;
    }
private:
    vector<vector<int>> ans;
    vector<int> res;
    void backtracking(const vector<int>&nums,vector<bool>used){
        if(res.size()==nums.size()){
            ans.emplace_back(res);
            return ;
        }

        for(int i=0;i<nums.size();++i){
            if(!used[i]){
                used[i] = true;
                res.emplace_back(nums[i]);
                backtracking(nums,used);
                res.pop_back();
                used[i] = false;
            }else continue;
        }
    }
};

47.全排列II

链接：LeetCode47.全排列II

class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<bool> used(nums.size(),false);
        backtracking(nums,used);
        return ans;
    }
private:
    vector<vector<int>> ans;
    vector<int>res;
    void backtracking(const vector<int>&nums,vector<bool>used){
        if(res.size()==nums.size()){
            ans.emplace_back(res);
            return ;
        }

        for(int i=0;i<nums.size();++i){
            //树层去重
            if(i>0&&nums[i]==nums[i-1]&&used[i-1]==false) continue;
            if(!used[i]){
                used[i] = true;
                res.emplace_back(nums[i]);
                backtracking(nums,used);
                res.pop_back();
                used[i] = false;
            }
        }
    }
};