#if !defined(AFX_QUEUELIST_H__E1E0BFBA_9B05_4657_9A37_52A6FBFD596A__INCLUDED_)
#define AFX_QUEUELIST_H__E1E0BFBA_9B05_4657_9A37_52A6FBFD596A__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class queuelist 
{
public:
 queuelist                                      ();
 virtual ~queuelist                             ();
 int JumpOut                                    ();
 int InserttheList                              (int element);
 void SetNull                                   ();
 bool ChargeEmpty                               ();
 bool ChargeFull                                ();
 int GetTotal_num                               ();
 int GetRear                                    () { return rear; }
 int GetFront                                   () { return front; }
private:
 int total_num;
 int Race_list[10];
 int front;
 int rear;
};

#endif // !defined(AFX_QUEUELIST_H__E1E0BFBA_9B05_4657_9A37_52A6FBFD596A__INCLUDED_)

 

#include "stdafx.h"
#include "queuelist.h"

#include <iostream>
using namespace std;

 

queuelist::queuelist()
{
 for(int i=0; i<9; i++)
 {
  Race_list[i] = i+1;
 }
 front = 9;
 rear = 8;
 total_num = 9;
}

queuelist::~queuelist()
{
}

int queuelist::InserttheList(int element)
{
 if(ChargeFull())
 {
  cout << "队列已满,不能再插入元素" << endl;
  return -1;
 }
 else
 {
  rear = (rear+1)%10;
  Race_list[rear] = element;
  total_num++;
  return Race_list[rear];
 }
}

int queuelist::JumpOut()
{
 if(ChargeEmpty())
 {
  cout << "队列为空,不能跳出元素" << endl;
  return -1;
 }
 else
 {
  front = (front+1)%10;
  total_num--;
  return Race_list[front];
 }
}

void queuelist::SetNull()
{
 front = 0;
 rear = 0;
}

bool queuelist::ChargeEmpty()
{
 if(rear == front)
  return true;
 else
  return false;
}

bool queuelist::ChargeFull()
{
 if(((rear+1)%10)==front)
  return true;
 else
  return false;
}

int queuelist::GetTotal_num()
{
 return total_num;
}

 

 

#include "stdafx.h"
#include "queuelist.h"

#include <iostream>
using namespace std;

typedef struct result{

 int Group_Record[9];

}RESULT;

 
typedef struct newr{

    int Crash_Record[9];
  
}NEWR;

//冲突矩阵//
 int R[][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}};

 

bool ChargeQuarrel(int* crash, int* ending, int position, int groups)
{
 if(crash[position]==0)
 {
  ending[position] = groups;
  for(int i=0; i<9; i++)
  {
   crash[i] = crash[i] + R[position][i];
  }
  return false;
 }
 
 else
 {
  return true;
 }
}

int main(int argc, char* argv[])
{
 int g_row = 1;
 queuelist cq;
 RESULT Into_dif_group;
 NEWR of_Crash;
 
    // 初始化 result 和 newr 两个数组//
 for(int i=0; i<9; i++)
 {
  Into_dif_group.Group_Record[i] = 0;
  of_Crash.Crash_Record[i] = 0;
 }
 //划分子集//
 while(!cq.ChargeEmpty())
 {
  int num = cq.GetTotal_num();
  for(int k=0; k<num; k++)
  {
   int temp = cq.JumpOut();
  
      //判断是否冲突//
      if(ChargeQuarrel(of_Crash.Crash_Record, Into_dif_group.Group_Record, (temp-1), g_row))
   {
       cq.InserttheList(temp);
   }
  }
  //清空冲突数组newr//
  for(int q=0; q<9; q++)
  {
   of_Crash.Crash_Record[q] = 0;
  }
        //组序号加一//
  g_row++;
 }

 //输出//
 for(int m=1; m<g_row; m++)
 {
  cout << "第" << m << "组元素:" << endl;
   for(int n=0; n<9; n++)
  {
   if(Into_dif_group.Group_Record[n]==m)
    cout << (n+1) << " ";
  }
  cout << endl;
 }
 return 0;
}