90. Subsets II

最新推荐文章于 2025-05-27 23:37:24 发布

ShenYounger

最新推荐文章于 2025-05-27 23:37:24 发布

阅读量309

点赞数

分类专栏： leetcode

leetcode 专栏收录该内容

220 篇文章

订阅专栏

本文探讨了在存在重复元素的情况下，如何高效地找出所有可能的子集，并详细介绍了两种不同的算法实现，包括深度优先搜索（DFS）方法和优化后的递归算法，以确保结果集中不包含重复子集。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given a collection of integers that might contain duplicates, S, return all possible subsets.

Note:

Elements in a subset must be in non-descending order.
The solution set must not contain duplicate subsets.

For example,
If S = [1,2,2], a solution is:

[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

分析：在上一题的基础上，可以允许集合中包含重复元素，我们也把相应的二叉树画出类，以集合{1,2,2}举例

算法1：dfs解法。注意到处理第三个元素2时，因为前面已经处理了一次2，所有第三层中，我们只在已经添加过2的集合{1,2}、{2}上再添加2，而没有在集合{1}, {}上添加2（画叉叉的那么分支），假设下面还有一个2，那么我们只在第四层的包含两个2的集合{1,2,2}、{2,2}上再添加2，其它都不添加。因此dfs时，如果当前处理的数字前面出现了k次，那么我们要处理的集合中必须包含k个该元素。代码如下：

class Solution {
private:
    vector<vector<int> >res;
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        //先排序，然后dfs每个元素选或者不选，最后叶子节点就是所有解
        res.clear();
        sort(S.begin(), S.end());
        vector<int>tmpres;
        dfs(S, 0, tmpres);
        return res;
    }
    void dfs(vector<int> &S, int iend, vector<int> &tmpres)
    {
        if(iend == S.size())
            {res.push_back(tmpres); return;}
        int firstSame = iend;
        while(firstSame >=0 && S[firstSame] == S[iend])firstSame--;
        firstSame++; //firstSame是第一个和S[iend]相同数字的位置
        int sameNum = iend - firstSame;//和S[iend]相同数字的个数(除自己)
        if(sameNum == 0 ||
            (tmpres.size() >= sameNum && tmpres[tmpres.size() - sameNum] == S[iend]))
        {
            //选择S[iend]
            tmpres.push_back(S[iend]);
            dfs(S, iend+1, tmpres);
            tmpres.pop_back();
        }
        //不选择S[iend]
        dfs(S, iend+1, tmpres);
    }
};

算法2：在上一题算法2的基础上，如果当前处理的元素没有出现过，则把前面得到的所有集合加上该元素；如果出现过，则只把上一轮处理的集合加上该元素。比如处理第二个2时（二叉树第三层），我们只把上一轮添加过数字的集合{1,2}、{2}再添加一个2加入结果中，{1}、{}是从上一层直接继承下来的，所以不作处理。代码如下：

class Solution {
private:
    vector<vector<int> >res;
public:
    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int len = S.size();
        sort(S.begin(), S.end());
        vector<vector<int> > res(1);//开始加入一个空集
        int last = S[0], opResNum = 1;//上一个数字、即将要进行操作的子集数量
        for(int i = 0; i < len; ++i) 
        {
            if(S[i] != last)
            {
                last = S[i];
                opResNum = res.size();
            }
            //如果有重复数字，即将操作的子集的数目和上次相同
            int resSize = res.size();
            for(int j = resSize-1; j >= resSize - opResNum; j--)
            {
                res.push_back(res[j]);
                res.back().push_back(S[i]);
            }
        }
        return res;
    }
};

2015年9月12号，代码

-----------------------------------------

class Solution {
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>> res;
        vector<int> item;
        res.push_back(item);
        int n = (int)nums.size();
        sort(nums.begin(), nums.end());
        int opNum = 1;
        for (int i=0; i<n; i++) {
            if (i!=0&&nums[i]!=nums[i-1]) {
                opNum = (int)res.size(); //即将要进行操作的子集数量
            }
            int size = (int)res.size();
            for (int j=size-1; j>=size-opNum; j--) { //如果有重复数字，即将操作的子集的数目和上次相同
                item = res[j];
                item.push_back(nums[i]);
                res.push_back(item);
            }
        }
        return res;
    }
};