子集生成的三种算法

子集生成算法：

给定一个集合，枚举所有可能的子集。暂时讨论没有重复元素的情况。

1 增量构造法

一次选出一个元素放到集合中，和前面不同，由于A中的元素个数不确定，每次递归都要输出当前集合。另外递归边界也不需要显式确定-如无法添加元素，就不会递归了。

注意：定序，规定集合A的所有元素的编号从小到大排列，就不会把集合{1,2}按照{1,2}和{2,1}输两次了

代码：

void print_subset(int n,int*A,int cur)
{
    for(int i = 0;i<cur;i++)
    {
        cout << A[i] << " ";
    }
    cout << endl;
    int s = cur? A[cur-1]+1 : 0;//确定当前元素最小可能值
    for(int i = s;i<n;i++)
    {
        A[cur] = i;
        print_subset(n,A,cur+1);
    }
}

将代码稍作修改后就可以输出P中的元素了，因为把1~n的子集放在A内，A就可以当P的子集的元素的索引了

代码：

void print_subset_2(int n,int*P,int*A,int cur)
{
    for(int i = 0;i<cur;i++)
    {
        cout << P[A[i]] << " ";
    }
    cout << endl;
    int s = cur?A[cur-1]+1:0;
    for(int i = s;i<n;i++)
    {
        A[cur] = i;
        print_subset_2(n,P,A,cur+1);
    }
}

2 位向量法

构造一个位向量B[i]，而不是直接构造子集A本身，其中B[i]=1，当且仅当i在子集A中。

代码：

void print_subset_3(int n,int*B,int cur)
{
    if(cur==n)
    {
        for(int i = 0;i<n;i++)
        {
            if(B[i]) cout << i << " ";
        }
        cout << endl;
        return;
    }
    B[cur] = 1;
    print_subset_3(n,B,cur+1);
    B[cur] = 0;
    print_subset_3(n,B,cur+1);
}

所有元素判断完是否选择后才是一个完整的子集。现在解答树上有2047个节点

这是一个n+1层二叉树（cur从0到n），第0曾有1个节点，第二层有两个节点（第一位是否选择），...，总数为1+2+...+2^n=2^(n+1)-1。

也可改进成输出P的形式

代码：

void print_subset_4(int n,int*P,int*B,int cur)
{
    if(cur==n)
    {
        for(int i = 0;i<n;i++)
        {
            if(B[i]) cout << P[i] << " ";
        }
        cout << endl;
        return;
    }
    B[cur] = 1;
    print_subset_4(n,P,B,cur+1);
    B[cur] = 0;
    print_subset_4(n,P,B,cur+1);
}

3 二进制法

思想上与位向量法近似。

代码：

void print_subset(int n,int s)
{
    for(int i = 0;i<n;i++)
    {
        //cout << s << " " << i << " " << (s&(1<<i)) << endl;
        if(s&(1<<i)) cout << i << " ";
    }
    cout << endl;
}
void print_subset_5(int n)
{
    for(int i = 0;i<(1<<n);i++)
    {
        //cout << i << endl;
        print_subset(n,i);
    }
}

可能理解起来有点绕，主要是用十进制的二进制表示和十进制的数值本身有点混

举个栗子：

现在n=4

那么在print_permutation_5里面我有循环了

0-15,二进制位从0-1111；它就相当于位向量，提供子集中元素出现的位置

接着对于每一个上面的数来依次与0~3做位移运算后得到的1,2,4,8，（二进制为0001,0010,0100,1000），来按位与，实际上是看0-3这个数在子集中是否出现

由于0-15已经含了对于元素个数为4的集合的所有子集的可能情况，那么与之后就得到该出现的子集元素。

代码汇总：

#include <iostream>
#define max_n 10005
using namespace std;
int A[max_n];
int B[max_n];
//增量构造法
void print_subset(int n,int*A,int cur)
{
    for(int i = 0;i<cur;i++)
    {
        cout << A[i] << " ";
    }
    cout << endl;
    int s = cur? A[cur-1]+1 : 0;//确定当前元素最小可能值
    for(int i = s;i<n;i++)
    {
        A[cur] = i;
        print_subset(n,A,cur+1);
    }
}
void print_subset_2(int n,int*P,int*A,int cur)
{
    for(int i = 0;i<cur;i++)
    {
        cout << P[A[i]] << " ";
    }
    cout << endl;
    int s = cur?A[cur-1]+1:0;
    for(int i = s;i<n;i++)
    {
        A[cur] = i;
        print_subset_2(n,P,A,cur+1);
    }
}
//位向量法
void print_subset_3(int n,int*B,int cur)
{
    if(cur==n)
    {
        for(int i = 0;i<n;i++)
        {
            if(B[i]) cout << i << " ";
        }
        cout << endl;
        return;
    }
    B[cur] = 1;
    print_subset_3(n,B,cur+1);
    B[cur] = 0;
    print_subset_3(n,B,cur+1);
}
void print_subset_4(int n,int*P,int*B,int cur)
{
    if(cur==n)
    {
        for(int i = 0;i<n;i++)
        {
            if(B[i]) cout << P[i] << " ";
        }
        cout << endl;
        return;
    }
    B[cur] = 1;
    print_subset_4(n,P,B,cur+1);
    B[cur] = 0;
    print_subset_4(n,P,B,cur+1);
}
//二进制法
void print_subset(int n,int s)
{
    for(int i = 0;i<n;i++)
    {
        //cout << s << " " << i << " " << (s&(1<<i)) << endl;
        if(s&(1<<i)) cout << i << " ";
    }
    cout << endl;
}
void print_subset_5(int n)
{
    for(int i = 0;i<(1<<n);i++)
    {
        //cout << i << endl;
        print_subset(n,i);
    }
}
int main()
{
    int P[] = {1,2,3,4};
    //print_subset_2(4,P,A,0);
    //print_subset_3(4,B,0);
    //print_subset_4(4,P,B,0);
    print_subset_5(4);
    return 0;
}