代码随想录训练营第25天|set去重

最新推荐文章于 2024-11-16 21:36:47 发布

jiyisuifeng1991

最新推荐文章于 2024-11-16 21:36:47 发布

阅读量289

点赞数 6

文章标签：深度优先算法 leetcode

本文链接：https://blog.csdn.net/jiyisuifeng1991/article/details/141988901

版权

491. 非递减子序列

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


    void dfs(vector<int>& nums, int startIdx){
        if(startIdx==nums.size()){
            return;
        }
        unordered_set<int> seen;
        for(int i=startIdx; i<nums.size(); i++){
            if((path.empty()||nums[i]>=path.back())&&!seen.count(nums[i])){
                path.push_back(nums[i]);
                seen.insert(nums[i]);
                if(path.size()>=2)
                    result.push_back(path);
                dfs(nums,i+1);
                path.pop_back();
            }
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        dfs(nums,0);
        return result;
    }
};

nums不能排序，所以无法用while在回溯后去重，只能借助set，记录当前层已经使用过的数值，通过count方法实现去重。

46. 全排列

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

    void dfs(vector<int>& nums){
        if(path.size()==nums.size()){
            result.push_back(path);
            return;
        }
        for(int i=0; i<nums.size(); i++){
            if(!used[i]){
                path.push_back(nums[i]);
                used[i]=true;
                dfs(nums);
                used[i]=false;
                path.pop_back();
            }
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        used.assign(nums.size(),false);
        dfs(nums);
        return result;
    }
};

排列需要考虑顺序，不能用startIdx递增搜索，通过标记数组used，搜索每一层未使用过的元素。

47. 全排列 II

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

    void dfs(vector<int>& nums){
        if(path.size()==nums.size()){
            result.push_back(path);
            return;
        }
        for(int i=0; i<nums.size(); i++){
            if(!used[i]){
                path.push_back(nums[i]);
                used[i]=true;
                dfs(nums);
                used[i]=false;
                path.pop_back();
                while(i+1<nums.size()&&nums[i+1]==nums[i])
                    i++;
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        used.assign(nums.size(),false);
        sort(nums.begin(),nums.end());
        dfs(nums);
        return result;
    }
};

本题nums可以进行排序，所以回溯后利用while过滤掉相同数值，即可实现去重。