Lintcode017.Subsets

Posted 2020-09-18 Vincent丶

题目：

题解：

Solution 1 ()

class Solution {
public:
    vector<vector<int> > subsets(vector<int> &S) {
        vector<vector<int> > res{{}};
        sort(S.begin(), S.end());
        for (int i = 0; i < S.size(); ++i) {
            int size = res.size();
            for (int j = 0; j < size; ++j) {
                vector<int> instance = res[j];
                instance.push_back(S[i]);
                res.push_back(instance);
                }
        }
        return res;
    }
};

Solution 1.2

class Solution {
public:
    vector<vector<int> > subsets(vector<int> &S) {
    vector<vector<int> > res(1, vector<int>());
    sort(S.begin(), S.end());
    
    for (int i = 0; i < S.size(); i++) {
        int n = res.size();
        for (int j = 0; j < n; j++) {
            res.push_back(res[j]);
            res.back().push_back(S[i]);
        }
    }

    return res;
    }
};

Solution 2 ()

class Solution {
public:
    vector<vector<int> > subsets(vector<int> &S) {
        vector<vector<int> > res;
        vector<int> v;
        sort(S.begin(), S.end());
        dfs(res, S, v, 0);
        return res;
    }
    void dfs(vector<vector<int> > &res, vector<int> S, vector<int> &v, int pos) {
        res.push_back(v);
        for (int i = pos; i < S.size(); ++i) {
            v.push_back(S[i]);
            dfs(res, S, v, i + 1);
            v.pop_back();
        }
    }
};

Bit Manipulation

This is the most clever solution that I have seen. The idea is that to give all the possible subsets, we just need to exhaust all the possible combinations of the numbers. And each number has only two possibilities: either in or not in a subset. And this can be represented using a bit.

There is also another a way to visualize this idea. That is, if we use the above example, 1 appears once in every two consecutive subsets, 2 appears twice in every four consecutive subsets, and 3 appears four times in every eight subsets, shown in the following (initially the 8 subsets are all empty):

[], [], [], [], [], [], [], []

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

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

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

Solution 3 ()

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& S) {
        sort(S.begin(), S.end());
        int num_subset = pow(2, S.size()); 
        vector<vector<int> > res(num_subset, vector<int>());

        for (int i = 0; i < S.size(); i++) {
            for (int j = 0; j < num_subset; j++) {
                if ((j >> i) & 1) {
                    res[j].push_back(S[i]);
                }
            }
        }
        return res;  
    }
};