LeetCode_Subsets

最新推荐文章于 2021-02-26 22:24:49 发布

原创最新推荐文章于 2021-02-26 22:24:49 发布 · 706 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #算法 #leetcode

LeetCode 专栏收录该内容

47 篇文章

订阅专栏

本文探讨了两种生成给定整数集合所有可能子集的方法。一种是基于BFS的搜索算法，另一种则是通过迭代扩展已找到的子集。两种方法都先对输入集合排序，并确保子集按非递减顺序排列且不含重复。

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

Given a set of distinct integers, 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,3], a solution is:

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

我能想到的解法就是BFS，基础数据 AC了但是，在DISCUSS上看到别人更高效的解法，和我的思路完全不一样。
先简要说明一下我的思路：
1.整体上我是按照子集合的元素个数进行BFS搜索的，空集必然包括在结果内，不多说，结果初始化为各单元素集合；
2.选取给定S中大于当前子集中最大元素的为选中元素对当前子集进行扩展，直到集合中的元素数到达S.size();

class Solution {
public:
    vector<vector<int> > subsets(vector<int> &S) {
        vector <vector<int>> result;
        result.push_back(vector <int>(0));
        if(S.size()==0){
            return result;
        }
        
        //sort S in non-descending order
        sort(S.begin(),S.end());
        vector <int> temps;
        queue <vector<int>> bfsQueue;
        //initialize bfs
        for(int i=0;i<S.size();i++){
            result.push_back(vector<int>(1,S[i]));
            bfsQueue.push(vector<int>(1,S[i]));
        }
        
        while(!bfsQueue.empty()){
            temps=bfsQueue.front();
            bfsQueue.pop();
            
            int maxE=temps[temps.size()-1];
            for(int k=0;k<S.size();k++){
                if(maxE<S[k]){
                    temps.push_back(S[k]);
                    bfsQueue.push(temps);
                    result.push_back(temps);
                    temps.pop_back();
                }
            }
        }
        return result;
    }
};

在discuss中看到别人的算法，同样首先对元素进行排序，然后使用S中的每个元素取扩展当前已经找到的子集合，也就是说每次找到的新增集合都是以当前最新元素为最大元素的子集合,代码如下：

class Solution {
public:
    vector<vector<int> > subsets(vector<int> &S) {
        vector <vector<int>> result(1);
        if(S.size()==0){
            return result;
        }
        
        //sort S in non-descending order
        sort(S.begin(),S.end());
        vector <int> temps;
        
        for(int i=0;i<S.size();i++){
            int j=result.size()-1;
            for(;j>=0;j--){
                result.push_back(result[j]);
                result.back().push_back(S[i]);
            }
        }
        return result;
    }
};

整体分析一下：两个算法的时间复杂度都是O(n*s的所有子集合数量)，但是第一个BFS使用了O（S所有子集合数目）的空间复杂度。