Subset I

roblem 1: Subset I

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], [] ]

Solve the problem on leetcode

大集合记录向量vector<vector<> > res;

小集合记录向量vector<>  tmp;

为保证不出现重复数组，加一个位置指标。pos.

pos表示该子集的起点，即从哪开始。某层用了i,下层用除此之外，从i+1开始。

循环回到该层时。去掉该层添加的该元素

class Solution {
public:
    vector<vector<int> > subsets(vector<int>& nums) {
        vector<vector<int> > res;
        vector<int> tmp;
         //注意与arraylist的区别。别new vector<int>();
        sort(nums.begin(),nums.end());
        res.push_back(tmp);
        dfs(res,tmp,nums,0);
        return res;
        }
        
        void dfs(vector<vector<int>> &res,vector<int> &tmp,vector<int>& nums,int pos)
        {
            for(int i=pos;i<nums.size();i++)
            {
                tmp.push_back(nums[i]);
                res.push_back(tmp);
                dfs(res,tmp,nums,i+1);
                tmp.pop_back();

     //注意vector的成员函数：

                
            }
        }
};

位排列解法

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        //先排序
        sort(nums.begin(),nums.end());
        int elem_size=nums.size();
        int subset_size=pow(2,elem_size);
        vector<vector<int>> subset_set(subset_size,vector<int>());
        for(int i=0;i<elem_size;i++)
        for(int j=0;j<subset_size;j++)
        if((j>>i)&1)
        subset_set[j].push_back(nums[i]);
        return subset_set;
    }
    
};

参考解释 leetcode上一位大神

leet_nik 

 This is an amazing solution.Learnt a lot.Let me try to explain this to those who didn't get the logic.

 Number of subsets for {1 , 2 , 3 } = 2^3 .
 why ? 
case    possible outcomes for the set of subsets
  1   ->          Take or dont take = 2 
  2   ->          Take or dont take = 2  
  3   ->          Take or dont take = 2 

therefore , total = 2*2*2 = 2^3 = { { } , {1} , {2} , {3} , {1,2} , {1,3} , {2,3} , {1,2,3} }

Lets assign bits to each outcome  -> First bit to 1 , Second bit to 2 and third bit to 3
Take = 1
Dont take = 0
 
0) 0 0 0  -> Dont take 3 , Dont take 2 , Dont take 1 = { } 
1) 0 0 1  -> Dont take 3 , Dont take 2 ,   take 1       =  {1 } 
2) 0 1 0  -> Dont take 3 ,    take 2       , Dont take 1 = { 2 } 
3) 0 1 1  -> Dont take 3 ,    take 2       ,      take 1    = { 1 , 2 } 
4) 1 0 0  ->    take 3      , Dont take 2  , Dont take 1 = { 3 } 
5) 1 0 1  ->    take 3      , Dont take 2  ,     take 1     = { 1 , 3 } 
6) 1 1 0  ->    take 3      ,    take 2       , Dont take 1 = { 2 , 3 } 
7) 1 1 1  ->    take 3     ,      take 2     ,      take 1     = { 1 , 2 , 3 } 

In the above logic ,Insert S[i] only if (j>>i)&1 ==true   { j E { 0,1,2,3,4,5,6,7 }   i = ith element in the input array }

element 1 is inserted only into those places where 1st bit of j is 1 
   if( j >> 0 &1 )  ==> for above above eg. this is true for sl.no.( j )= 1 , 3 , 5 , 7 

element 2 is inserted only into those places where 2nd bit of j is 1 
   if( j >> 1 &1 )  == for above above eg. this is true for sl.no.( j ) = 2 , 3 , 6 , 7

element 3 is inserted only into those places where 3rd bit of j is 1 
   if( j >> 2 & 1 )  == for above above eg. this is true for sl.no.( j ) = 4 , 5 , 6 , 7 

Time complexity : O(n*2^n) , for every input element loop traverses the whole solution set length i.e. 2^n

leet_nik