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

这个题看上去挺简单。。。。就是不会。。。。就是需要把这个集合进行组合，由于这个序列是有序的，因此需要排序，可以看看这篇文章，快排

当这个数组排序之后就可以进行正常的了，看到这个题，可以想起是全排列，神马和全排列能相对应的呢。。。。

这里用的是二进制，如有2位，则有这几种00,01,10,11,则2^2-1=3,那么这几种情况其实就是从0~2^i-1，只要把这个范围的二进制和数组进行&操作就可以。。。

如这个数组为{1,2,3,4,5,6}二进制数，比如00101，代表取数组中的第0个和第2个。

这个题的关键在于如何从00101中取第0个和第2个：

主要是使用&符号，如1&i，代表取二进制的第1位

代码（44ms）：

class Solution {
public:
    vector<vector<int> > subsets(vector<int> &S) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        vector<vector<int> >result;
        //先用快速排序对数组进行排序
        quickSort(S , 0 , S.size()-1);

        
        for(int i = 0; i < (1<< S.size()); ++i)
        {
            vector<int> subset;
            int idx = 0;
            int j = i;
            while(j > 0)
            {
                if(j & 1)
                    subset.push_back(S[idx]);
                j = j >> 1;
                ++idx;
            }
            result.push_back(subset);
        }
        return result;
        
    }
    
    
    void quickSort (vector<int>&a , int start , int end ){
        if(start>=end)return;
        
        int middle = partition(a,start ,end);
        quickSort(a,start,middle-1);
        quickSort(a,middle+1,end);
    }
    
    int partition(vector<int>&a,int low,int high)
    {
        int t=a[low];
        while(low<high)
        {
            while(low<high&&a[high]>=t)//high从右到左找小于t的记录
            high--;
            if(low<high)//找到小于t的记录则进行交换
            {
                a[low]=a[high];
                low++;
            }
            while(low<high&&a[low]<t)//low从左向右找大于t的记录
                low++;
            if(low<high) //找到则交换
            {
                a[high]=a[low];
                high--;
            }
        }
        a[low]=t; //将基准元素保存到low=high的位置
        return low;
    }

};