LeetCode_Subsets

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所有子集合数目）的空间复杂度。