循环队列：C语言实现划分无冲突子集

循环队列：C语言实现划分无冲突子集

问题描述

集合A如下：
A={1,2,3,4,5,6,7,8,9}，
集合R中(a,b)表示a与b是冲突关系，不能放在同一子集中：
R={ (2,8), (9,4), (2,9), (2,1), (2,5), (6,2), (5,9),(5,6), (5,4), (7,5), (7,6), (3,7), (6,3) }，
求一可行的子集划分，使A划分为互不相交的子集，并使子集个数尽量少。
可行的子集划分为：
A1 = {1，3，4，8}， A2 = {2，7}， A3 = {5}， A4 = {6，9}

算法思想

利用循环筛选。从第一个元素开始，凡与第一个元素无冲突的元素划归一组；再将剩下的元素重新找出互不冲突的划归第二组；直到所有元素进组
所用数据结构

1. 冲突关系矩阵
   r[i][j]=1, i, j有冲突
   r[i][j]=0, i, j无冲突

2. 循环队列cq[n]

3. 数组result[n]存放每个元素分组号

4. 工作数组newr[n]

工作流程

1. 将所有元素加入到循环队列中
2. 先取出第1元素，将该元素设置为当前元素CurItem，此时的队尾元素存入PreItem（作为整个队列循环完毕的标志），同时将冲突矩阵的第一列r[1][0-9]取出放入newr[0-9]中
3. 取出第2个元素，判断是否与当前元素冲突，若冲突，则重新排入队尾；若不冲突，则result[2] = Group，此时的组别为1，即第二个元素和第一个元素在同一组，同时冲突矩阵里面也要加入第二个元素的信息，因为后续元素的加入要同时判断两个元素的冲突信息
4. 如此循环，直到队首指针指到PreItem的时候，第一组循环完毕
5. 开始第二个组别的循环，更新冲突矩阵，更新组别即可
6. 一直循环直到队列为空，所有元素都以分好组

代码实现

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 10

typedef int Item;

// 循环队列的结构体
typedef struct SqQueue{
    Item *base;// 队列元素
    int front;// 队首
    int rear;// 队尾
}SqQueue;

// 完成该算法需要的顺序队列方法
// 1. 队列的初始化
// 2. 队列判断是否为空
// 3. 判断队列是否为满
// 3. 队列元素的增加
// 4. 队列元素的删除

// 方法的实现

// 1. 队列的初始化
// 初始化队首指针和队尾指针全部指向队首
// 队内没有元素
void InitQueue(SqQueue *Q){
    Q->base = (Item*)malloc(MAXSIZE *sizeof(Item));
    if(Q->base == NULL){
            printf("内存分配失败");
    }
    Q->front = Q->rear = 0;
}

// 2.判断队列是否为空
int IsEmpty(SqQueue q){
    if(q.rear == q.front){
        return 1;
    }
    return 0;
}

int IsFull(SqQueue q){
    if((q.rear+1)%MAXSIZE ==q.front){
        return 1;
    }
    return 0;
}

// 3.队列元素的增加
int EnQueue(SqQueue *q,int e){
    if((q->rear + 1)%MAXSIZE == q->front){
        return 0;
    }
    q->base[q->rear] = e;
    q->rear = (q->rear + 1)%MAXSIZE;
    return 1;
}

// 4.队列元素的删除
int DeQueue(SqQueue *q,int *x){
    if(q->front == q->rear){
        return 0;
    }
    *x = q->base[q->front];
    q->front = (q->front + 1)%MAXSIZE;
    return 1;
}

void PrintQueue(SqQueue q){
    int len = (q.rear-q.front+MAXSIZE)%MAXSIZE;
    int i,j;
    for(i = 0,j = q.front;i<len;i++,j = (j+1)%MAXSIZE){
        printf("%d ",q.base[j]);
    }
}

// 5.分类的实现
void DivdeQueue(int R[][9]){
    int result[9] = {0};// 结果矩阵，存放分组结果
    int Group = 0;// 组号

    // 创建循环队列同时初始化
    SqQueue q;
    InitQueue(&q);

    // 将元素排入队列
    for(int i = 0;i<9;i++){
        EnQueue(&q,i);
    }

    int PreItem = q.rear;
    int CurItem;


    int newr[9] = {0};

    while(!IsEmpty(q)){

        Group += 1;

        for(int i = 0;i<9;i++){
            newr[i] = R[q.base[q.front]][i];
        }


        while(q.front!=PreItem){
            DeQueue(&q,&CurItem);
            if(newr[CurItem]==0){
                result[CurItem] = Group;
                for(int i = 0;i<9;i++){
                    newr[i] += R[i][CurItem];
                }
            }else{
                EnQueue(&q,CurItem);
            }
        }
        PreItem = q.rear;
    }
    
    printf("开始输出结果");
    printf("\n");

    for(int p = 1;p<=Group;p++){
        for(int q = 0;q<9;q++){
            if(result[q]==p){
                printf("%d ",q+1);
            }
        }
        printf("\n");
    }
}

int main(){
    int R[9][9] = {
        0,1,0,0,0,0,0,0,0,
        1,0,0,0,1,1,0,1,1,
        0,0,0,0,0,1,1,0,0,
        0,0,0,0,1,0,0,0,1,
        0,1,0,1,0,1,1,0,1,
        0,1,1,0,1,0,1,0,0,
        0,0,1,0,1,1,0,0,0,
        0,1,0,0,0,0,0,0,0,
        0,1,0,1,1,0,0,0,0
    };

    DivdeQueue(R);
    return 0;
}