子集树和排列树

子集树

子集树：当所给的问题是从n个元素的集合S中找出满足某种性质的子集时，相应的解空间称为子集树。例如，物品的0-1背包问题所相应的解空间树就是一颗子集树。这类子集问题通常有2^n个叶节点，其节点总个数为2^(n+1)-1。遍历子集树的任何算法均需要O(2^n)的计算时间（均需要遍历完所有的分支）。

• 现需打印序列（长度为n）的全部子集，将问题抽象转化为一棵二叉树.
• 一个序列的所有子集为2^n，即可看成具有2^n个叶节点的满二叉树，总结点个数为2^(n+1)-1.
• 需定义额外数组保存当前分支的打印信息（左分支置1，右分支置0）
• 每遍历完一条分支，打印当前分支序列

/*子集树递归代码*/
void fun(int *ar,int *br,int i,int n)
{
    if(i == n)//每当i == n 时，打印该分支元素
    {
        for(int j = 0;j < n;j++)
        {
            if(br[j])
            {
                cout<<ar[j]<<" ";
            }
        }
        cout<<endl;
    }
    else
    {
        br[i] = 1;
        fun(ar,br,i+1,n);// left 左边子树 置1
        br[i] = 0;
        fun(ar,br,i+1,n);//right 右边子树 置0
    }
}
void main()
{
    int ar[] = {1,2,3};
    int br[] = {0,0,0};//辅助数组
    int n = sizeof(ar)/sizeof(ar[0]);
    fun(ar,br,0,n);
}

/*子集树循环代码*/
void fun(int *ar,int *br,int i,int n)
{
    int k = 0;
    br[k] = -1;
    while(k >= 0)
    {
        br[k] += 1;
        if(br[k] <= 1)
        {
            if(k == n)
            {
                for(int i = 0;i < n;++i)
                {
                    if(br[i])
                    {
                        cout<<ar[i]<<" ";
                    }
                }
                cout<<endl;
                --k;
            }
            else
            {
                k++;
                br[k] = -1;
            }
        }
        else
        {
            --k;
        }
    }
}
void main()
{
    int ar[] = {1,2,3};
    int br[] = {0,0,0,0};//辅助数组
    int n = sizeof(ar)/sizeof(ar[0]);
    fun(ar,br,0,n);
}

排列树

排列树：当所给问题是确定n个元素满足某种性质的排列时，相应的解空间树称为排列树。排列树通常有n!个叶子节点。因此遍历排列树需要O(n!)的计算时间。

• 打印出序列的全排列

/*排列树*/
void Perm(int *ar,int k,int m)
{
    if(k == m)
    {
        for(int i = 0;i <= m;i++)
        {
            cout<<ar[i]<<" ";
        }
        cout<<endl;
    }
    else
    {
        for(int j = k;j <= m;j++)
        {
            Swap(ar[k],ar[j]);
            Perm(ar,k+1,m);
            Swap(ar[k],ar[j]);
        }
    }
}

void main()
{
    int ar[] = {1,2,3};
    int n = sizeof(ar)/sizeof(ar[0]);
    Perm(ar,0,n-1);
}