（nice）LeetCode 90. 子集 II (位运算 || dfs)

最新推荐文章于 2024-05-20 20:08:58 发布

岁忧

最新推荐文章于 2024-05-20 20:08:58 发布

阅读量303

点赞数 6

分类专栏： LeetCode 文章标签： leetcode 算法职场和发展 c++ 深度优先遍历位运算

本文链接：https://blog.csdn.net/weixin_46028214/article/details/138372407

版权

LeetCode 专栏收录该内容

201 篇文章 0 订阅

订阅专栏

90. 子集 II

在这里插入图片描述
思路：有三种方法解决本题
方法一：我们用位运算，这里数组个数最多为10，那么我们就用第一层循环把0~2^lens - 1都遍历一遍i，再用第二层循环来遍历对应的数i二进制下哪些位置为1，为1就代表选中。然后用集合来确保不会有重复的。时间复杂度0(2^n)

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>> v;
        set<vector<int>> st;
        //下面这个sort，和后面的sort选一个用就可以。
        //原因就是因为排好序后，就不用怕集合里的元素因为“数组里元素位置不同（包含的数都一样，但位置不一样）”而不同
        //sort(nums.begin(),nums.end());
        int lens=nums.size();
        for(int i=0;i<(1<<lens);i++){
            vector<int > tmp;
            for(int j=0;j<lens;j++){
                if(i>>j&1){
                    tmp.push_back(nums[j]);
                }
            }
            sort(tmp.begin(),tmp.end());
            if(st.find(tmp)==st.end()){
                st.insert(tmp);
                v.push_back(tmp);
            }
        }
        return v;
    }
};

方法二：用dfs再加上一个集合来去重

class Solution {
public:
    vector<vector<int>> v;
    vector<int> tmp;
    set<vector<int>> st;
    void dfs(vector<int>& nums,int u){
        if(u==nums.size()){
            if(st.find(tmp)==st.end()){
                v.push_back(tmp);
                st.insert(tmp);
            }
            return ;
        }
        tmp.push_back(nums[u]);
        dfs(nums,u+1);
        tmp.pop_back();
        dfs(nums,u+1);
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        dfs(nums,0);
        return v;
    }
};

方法三：速度最快，避免了重复元素的大量遍历操作，而且还节省空间。在dfs里通过一层for循环来将深度变成宽度。具体细节看注释

class Solution {
public:
    vector<vector<int>> v;
    vector<int> tmp;
    void dfs(vector<int>& nums,int u){
        if(u==nums.size()){
            v.push_back(tmp);
            return ;
        }
        for(int i=u;i<nums.size();i++){
            if(i==u||(i!=u&&nums[i-1]!=nums[i])){ 
            //在这里排除的是对重复元素的二次dfs
            //重复元素的第一次dfs里的选，然后再下一层dfs里的不选，其实就已经重复了第二次dfs
                tmp.push_back(nums[i]);
                dfs(nums,i+1);
                tmp.pop_back();
            }
            //在这里加上这个就是因为题目要的是所有可能的子集
            //不加上会漏掉u~nums.size()-1里均不选的情况
            if(i==nums.size()-1){
                v.push_back(tmp);
                return ;
            }
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(),nums.end());//先排序，好在dfs里对重复的元素进行操作
        dfs(nums,0);
        return v;
    }
};