高效生成集合的固定子集划分

本文章讨论的是将一个包含n个不同元素的集合分割为所有的s个不为空的集合，且每次生成的s个集合不需要考虑顺序关系。相关的背景内容在我的倒数第四篇博客中已经说了，这篇文章主要是贴代码。

#include <stdio.h>
#include <malloc.h>
#define SET 6
#define PART 3
//这里我们执行的时候用先进先出队列来模拟整个的生成情况
struct set_par_link
{
    int* new_set;//代表当前的生成的集合划分
    struct set_par_link* next_set_par;//代表的是另外的一个集合划分
};
struct set_par_link* set_par_link_head=NULL;
struct set_par_link* set_par_link_rear=NULL;
int* standard_set_par;//代表的是初始的集合划分
//这两个是整个链表的头部与尾部，用来插入与删除,初始化为空.
void output(int* new_set)//输出函数,给定开始地址。
{
    int for_i,for_j;
    for (for_i = 0; for_i < SET; for_i++)
    {
        printf("%d ", new_set[for_i]);
    }
    printf("\n");
    for(for_i=1;for_i<=PART;for_i++)
    {
        printf("(");
        for (for_j = 0; for_j < SET; for_j++)
        {
            if (new_set[for_j] == for_i)
            {
                printf("%d ", for_j+1);
            }
        }
        printf(")  ");
    }
    printf("\n");
}
void insert_new_set_par(int* new_set_par)
{
    struct set_par_link* new_set_par_link;
    new_set_par_link = (struct set_par_link*)malloc(sizeof(struct set_par_link));
    new_set_par_link->new_set = new_set_par;
    new_set_par_link->next_set_par = NULL;
    if (set_par_link_head == NULL)
    {
        set_par_link_head = set_par_link_rear = new_set_par_link;
    }
    else
    {
        set_par_link_rear->next_set_par = new_set_par_link;
        set_par_link_rear = new_set_par_link;
    }
}
int type_one(int* father_set_par)//对当前的集合划分做第一种操作的逆操作
{
    int for_i,reverse,equal;//equal是用来记录第一个相等的对，reverse是用来记录第一个逆序的对
    int* new_set_par;
    new_set_par = (int*) malloc(sizeof(int) *SET);
    for (for_i = 0; for_i < SET; for_i++)
    {
        new_set_par[for_i] = father_set_par[for_i];
    }
    for_i=SET-2;
    equal=reverse=-1;
    while(for_i>=0)
    {
        if(new_set_par[for_i+1]<new_set_par[for_i])//当发现逆序时
        {
            if(reverse!=-1)//如果已经发现了逆序的对，则当前序列不可能是子序列根据一型操作生成的
            {
                free(new_set_par);
                return 0;//所以直接返回
            }
            else
            {
                if(equal!=-1)//如果已经发现了相等的对，则当前序列也不可能通过一型操作生成
                {
                    free(new_set_par);
                    return 0;//直接返回
                }
                else//否则，记录下当前的逆序索引
                {
                    reverse=for_i;
                }
            }
        }
        else//当不是逆序时
        {
            if(new_set_par[for_i+1]==new_set_par[for_i])//如果发现的是相等的对
            {
                if(equal==-1)//如果之前木有发现相等的对
                {
                    equal=for_i;//则直接赋值
                }
                //这样我们就记录了从右到左的第一个相等的对
            }
        }
        for_i--;//遍历
    }
    if(reverse==-1)//最后如果逆序对不存在
    {
        if (equal != SET - 2)
        {
            new_set_par[equal + 1]++;//直接对相等的那个对后面的那个数加一
        }
        else//如果最后一对是相等的，则不可能是通过第一个操作生成的
        {
            free(new_set_par);
            return 0;
        }
    }
    else//如果逆序对存在
    {
        if(new_set_par[reverse+1]+1<new_set_par[reverse])//如果这个逆序的差值大于1，则不可能由一型操作生成
        {
            free(new_set_par);
            return 0;
        }
        else//如果相差刚好为1，我们还需要考虑后面的那个数是否比逆序对后面的那个数刚好大一
        {
            if (new_set_par[reverse + 2] == new_set_par[reverse])
            {
                new_set_par[reverse + 1]++;
            }
            else
            {
                free(new_set_par);
                return 0;
            }
        }
    }
    insert_new_set_par(new_set_par);
    return 1;
}
int type_two(int* father_set_par)
{
    int for_i,temp,for_j,for_k,for_m;
    int* new_set_par;
    int* second_new_set_par;
    new_set_par = (int*) malloc(sizeof(int) *SET);
    for (for_i = 0; for_i < SET; for_i++)
    {
        new_set_par[for_i] = father_set_par[for_i];
    }
    for_i = SET - 2;
    while( (new_set_par[for_i] <=new_set_par[for_i + 1])&&for_i>=0)//寻找从右边开始的第一个逆序对
    {
        for_i--;
    }//这里由限制生长的性质，从右数第一个逆序对不可能是开头的第一个对
    //下面来讨论的是第二个操作没有生成新逆序对的情况
    //我们需要扫描每一个在for_i右边的增序对，并考虑他的可行性
    for_j = SET - 2;
    while (for_j > for_i)//遍历
    {
        if (new_set_par[for_j] < new_set_par[for_j + 1])//增序对
        {
            for_k = for_j - 1;
            while( (new_set_par[for_k] < new_set_par[for_j])&&for_k>=0)
            {
                for_k--;
            }
            if (for_k != -1)//如果当前值并不比前面所有的值都大，则交换之后遵守k限制增长规则
            {
                second_new_set_par = (int*) malloc(sizeof(int) *SET);//这里我们要建立副本，因为可能会有多个
                for (for_m = 0; for_m < SET; for_m++)
                {
                    second_new_set_par[for_m] = new_set_par[for_m];
                }
                //然后进行调换
                temp = second_new_set_par[for_j + 1];
                second_new_set_par[for_j + 1] = second_new_set_par[for_j];
                second_new_set_par[for_j] = temp;
                insert_new_set_par(second_new_set_par);
            }
            else//如果当前值比之前的都大，都不可能是通过第二种操作生成的。例子，11123不可以由11132生成，因为
                //后者违反了k生长的规则
            {
                //do nothing
            }//其实这里的判断可以合并起来
        }
        else
        {
            //do nothing
        }
        for_j--;
    }
    if (for_i != -1)//此时对应的是生成的父节点有逆序对的情况
    {
        if (new_set_par[for_i - 1] <= new_set_par[for_i + 1])//对应的是二型操作生成了新逆序对的情况
        {
            for_k = for_j - 2;
            while (for_k >= 0 && (new_set_par[for_k] < new_set_par[for_j - 1]))
            {
                for_k--;
            }//同样需要考虑当前值和前一个值都是第一次出现的情况，这种情况下是不合法的
            if (for_k == -1)//例子11232不可以由11322生成，因为后者不是k限制生长的。
            {
                free(new_set_par);
                return 0;
            }
            second_new_set_par = (int*) malloc(sizeof(int) *SET);//这里我们要建立副本，因为可能会有多个
            for (for_m = 0; for_m < SET; for_m++)
            {
                second_new_set_par[for_m] = new_set_par[for_m];
            }
            //然后进行调换
            temp = second_new_set_par[for_i - 1];
            second_new_set_par[for_i  -1] = second_new_set_par[for_i];
            second_new_set_par[for_i] = temp;
            insert_new_set_par(second_new_set_par);
        }//逆向操作交换一下就可以了
        else
        {
            //do nothing
        }
    }
    else
    {
        //do nothing 因为其他的留给下面的过程去考虑
    }
    free(new_set_par);
    return 0;
}


int main()
{
    int for_i,for_j;
    struct set_par_link* temp_set_par_link;
    standard_set_par = (int*) malloc(sizeof(int) *SET);
    for(for_i=0;for_i<SET-PART;for_i++)
    {
        standard_set_par[for_i]=1;
    }
    for(for_j=1;for_j<=PART;for_j++)
    {
        standard_set_par[for_i+for_j-1]=for_j;
    }
    insert_new_set_par(standard_set_par);//插入第一个节点，即头节点
    while (set_par_link_head != NULL)//然后开始进行层序遍历
    {
        type_two(set_par_link_head->new_set);
        type_one(set_par_link_head->new_set);
        temp_set_par_link = set_par_link_head->next_set_par;
        output(set_par_link_head->new_set);
        free(set_par_link_head->new_set);
        free(set_par_link_head);
        set_par_link_head = temp_set_par_link;
    }
}