35课队伍排列问题，求注释感谢！！

林小尖

设有 2n（n<=6）个球队进行单循环比赛，计划在 2n - 1 天内完成，每个队每天进行一场比赛。设计一个比赛的安排，使在 2n - 1 天内每个队都与不同的对手比赛。

例如 n = 2 时的比赛安排为：

编号  第一天 第二天  第三天
   1.         2.           3.         4
   2.         1.           4.         3
   3.         4.           1.         2
   4.         3.           2.         1
n = 2 时，共有 4 个队伍参加比赛，他们的编号分别是：1、2、3、4。

第一天编号为 1 的队伍对战编号为 2 的队伍，编号为 3 的队伍对战编号为 4 的队伍；第二天 1 跟 3 打，2 跟 4 打；最后一天 1 跟 4 打，2 跟 3 打。这样只需要三天的时间，就实现了让每个队都与不同的对手只进行一场比赛。

jhq999

//其实用递归可能更简单

int main()//其实用递归可能更简单
{
        int num=12,h=0,i=0,istart=0,jstart=0,j=0,k=0,L=0,Lstart=1,m=0;
        int a[12+1][12+1]={0},b[6][2]={0};//数组a表示所有的对阵，包括自己和自己对阵和没有的0队，为了方便直接把0队也放里面了
                                    //数组b一天的对阵，例如第一组对阵1队对3队，那么b[0][0]=1，b[0][1]=3,以此类推
        for (i = 0; i < num+1; i++)//图一，去掉0队和重复对阵
        {
                a[0][i]=1;
                a[i][0]=1;
                for (j = 1; j < i+1; j++)
                {
                        a[i][j]=1;
                }
        }
        Lstart=1,istart=2,jstart=1;
        for ( h = 2; h <=num; h++)
        {
                b[0][0]=1,b[0][1]=h;//先装入1队和其他队对阵作为第一组
                L=Lstart;
                
                for (i = istart; i <= num; i++)//i表示每一组对阵的第一个队
                {
                        //istart=2;
                        if (L==num/2)//b满员退出，节省循环次数
                        {
                                break;
                        }
                        for (int j = jstart; j <= num; j++)//j表示每一组对阵的第二个队
                        {
                                //jstart=1;
                                if (!a[i][j])//没有过对阵
                                {


                                        for (m = 0; m < L; m++)
                                        {
                                                if ((b[m][1]==i)||(b[m][1]==j))break;//一组里面的队和前面对阵对比是否前面已经对过阵了

                                        }
                                        if (L==m)//这一组对阵的队没有对过阵，加入对阵
                                        {
                                                b[L][0]=i,b[L][1]=j;
                                                L++;
                                                break;
                                        }
                                }
                        }

                }
                if (L==num/2)//正确不重复对阵满员，输出
                {
                        for ( m = 0; m <L; m++)
                        {
                                a[b[m][0]][b[m][1]]=1;//设置成1表示这组对阵已经用过
                                printf("%d-%d,",b[m][0],b[m][1]);
                        }
                        printf("\n");
                         Lstart=1,istart=2,jstart=1;
                }
                else if((num+1)==j)//b没有满员,而且整个循环结束，回到b数组上一组，且从记录的j再加一开始循环，
                {
                        
                       L--;
                        while(b[L][1]==num)//记录的j是最后一个，那么再寻找前面那一组
                        {
                                L--;
                        }
                        Lstart=L;
                        h--;
                        istart=b[L][0];
                        jstart=b[L][1]+1;
                }
        }
        return 0;
}