网球循环赛比赛日程表n为奇数问题

初衷

在教材上看到这个问题的时候，对于奇数的处理百思不得其解，然而网上的答案要么就是n=2^k的状况，要么就是本身根本都没有理解，给你讲了一大堆，各类状况，很麻烦，甚至有些是错的误人子弟。因此写下这篇思路，分享给各位。其实这个问题的核心就是分治的治该怎么去构造的问题。

问题

设有N个运动员要进行网球循环赛，设计一个知足如下要求的比赛日程表

（1）每一个选手必须与其余n-1个选手各赛一次

（2）每一个选手一天只能赛一次

（3）当n 是偶数，循环赛进行n-1天，当n是奇数，循环赛进行n天。

算法分析

1. 咱们采用分治法，先算出n/2的状况，而后进行合并，构造出n的状况。难点就在于构造过程,设第i个选手第j天比赛的队员为A[i][j]。
2. 若m = n/2为偶数，这时候咱们知道偶数人数已经算出了前m个队员的前passed_days天(对于偶数而言是m-1，对于奇数是m)的比赛状况，咱们怎么构造呢？
   • 先横向构造，也就是构造出后m个队员在前m-1天的比赛状况，那么为了保证不重复咱们采用递增的构造方式，让i+m号选手与比A[i][j]大m的选手比赛，也是是说
     • A[i + m][j] = A[i][j] + m; (1≤i≤m,1≤j≤passed_days,i表明队员，j表明当前比赛的天数)
     • 能够看出来必定不会重复，由于前m个队员以前从未与后m个队员比胜过，而后A[i][j]彼此又是互不相同的，因此A[i+m]彼此也必定不相同
   • 再纵向构造，设n个队员比赛所需总天数为days(对于偶数而言是n-1，对于奇数是n)，也就是说构造n个队员在后（days - passed_days）天的比赛状况，一样为了保证不重复咱们也采用增量构造,
     • passed_days +1≤j≤days，
     • rvalue = (count + i-1)%m + m+1;//保证i队员与后面的队员（rvalue必然大于m）比赛，这样就与前面passed_days天的比赛不重复
     • count为增量初始值为0，j每加1，count++
     • A[i][j] = rvalue;
     • A[rvalue][j] = i; //由于是两两比赛，后面m对用中的与之对应个队员直接构造出来
   • 须要注意的是纵向构造的时候咱们先构造A[1][j]也就是说先保证第一个队员在（days - passed_days）比赛的队员确定与以前（passed_days）是不一样的，那么因为i也是递增的因此，A[i][j]彼此之间一定也是互不相同的！

• 举个栗子：假设n=4.

先计算n/2 = 2,咱们知道A[1][1] = 2,A[2][1] = 1（偶数比赛只有一天）

1 2（队员编号）

2 1（第一天）
复制代码

接下来咱们构造，n=4，此时days = 3,passed_days = 1，m=2

横向构造：

1 2 3 4
2 1 4 3
复制代码

纵向构造A[1][j]：

1 2 3 4
2 1 4 3
3   1 
4     1
复制代码

接着纵向构造A[2][j]：

1 2 3 4
2 1 4 3
3 4 1 2
4 3 2 1
复制代码

3. 若m = n/2为奇数的话，咱们须要特殊处理下

   • 因为咱们是按照偶数的边界构造的，也就是奇数的时候实际上扩充为了m+1列，那么咱们须要把与m+1比赛的队员置0，删掉多余的m+1列
   • 其次因为置0，那么横向构造的时候若是A[i][j]=0,说明i队员在j天没有比赛，咱们直接让他与i+m号选手比赛（保证与以前的横向构造的增量一致）

   • A[i + m][j] = i;
           A[i][j] = i + m;
     复制代码

   • 可是上面也引发了问题就是，咱们在纵向构造的时候A[1][passed_days]可能会重复（由于在为0的位置可能填入了m+1的元素，因此咱们须要标记一下，若是是奇数的话纵向构造的其实增量+1），只要保证了A[1][j]不重复，后面由于都是增量构造确定不会重复 r_value = (count + (i - 1) + 1) % m + m + 1;

仍是举两个例子：

n=3的构造状况

1.先算n=2

1 2
2 1
复制代码

2.m=2，passed_days=1,days = 3横向构造

1 2 3 4
2 1 4 3
复制代码

3.纵向构造A[1][j],j=2,3

1 2 3 4
2 1 4 3
3   1
4     1
复制代码

4.纵向构造A[2][j],j=2,3

1 2 3 4
2 1 4 3
3 4 1 2
4 3 2 1
复制代码

5.把扩充的置0，同时删掉多余的第4列

1 2 3 
2 1 0 
3 0 1 
0 3 2 
复制代码

n=6的构造状况

1.首先n/2=3已经算出

2.m=3，passed_days=3,days = 5横向构造A[i][1]，即第一天的

1 2 3 4 5 6
2 1 6 5 4 3
3 0 1 
0 3 2 
复制代码

3.接着横向构造完全部passed_days天的

1 2 3 4 5 6
2 1 6 5 4 3
3 5 1 6 2 4
4 3 2 1 6 5
复制代码

4.纵向构造A[1][4],A[1[5],因为m是奇数因此，构造增量加了1即A[1][4] = (0 + (1 - 1) + 1) % 3 + 3 + 1 = 5;

1 2 3 4 5 6
2 1 6 5 4 3
3 5 1 6 2 4
4 3 2 1 6 5
5       1
6         1
复制代码

5.纵向构造完（因为n是偶数，不须要再进行置0操做）

2   1   6   5   4   3   
3   5   1   6   2   4   
4   3   2   1   6   5   
5   6   4   3   1   2   
6   4   5   2   3   1  
复制代码

C++代码

#include <iostream>
#include <iomanip>
#include <cmath>

using namespace std;
const int MAX_NUM = 100;
int A[MAX_NUM+2][MAX_NUM+2];
/* 合并子问题 */
void merge(int n)
{
    /*
     * n 为偶数时，比赛 n - 1 天
     * n 为奇数时，比赛 n 天
     */
    int days = n&1 ? n  : n-1;
    /*
     * 中间值，若n为奇数，则使 m = (n / 2) + 1,
     * 即，前半部分不小于后半部分
     */
    int m = (int)ceil(n / 2.0);
    int passed_days = m& 1? m : m - 1;    /* 已经安排的天数 */

    /*
     *  经过前 n/2 的比赛安排，构造后n/2的比赛安排
     *  若是 n 为奇数，则会产生一个虚拟选手
     */
    for (int i = 1; i <= m; i++)
    {
        for (int j = 1; j <= passed_days; j++)
        {
            if (A[i][j] != 0)   /* 若是 i 号在第 j 天有对手 */
            {
                /*
                 * 那么，(i + m) 号在第 j 天的对手为 i号的
                 * 对手日后数 m 号
                 */
                A[i + m][j] = A[i][j] + m;
            }
            else   /* 若是 i 号在第 j 天没有对手*/
            {
                /*
                 * 那么就让 i 号和 （i + m）号互为对手
                 */
                A[i + m][j] = i;
                A[i][j] = i + m;
            }
        }
    }

    int add_one = 0;        /*标志子问题是不是奇数，若是是的话构造增量加1 */
    if (A[1][passed_days] == m + 1)
        add_one = 1;
    for (int i = 1; i <= m; i++)
    {
        for (int j = passed_days + 1, count = 0; j <= days; j++, count++)
        {
            /*
             * 构造i 号在第 j 天的对手
             */
            int r_value = (count + (i - 1)  + add_one) % m + m + 1;
            A[i][j] = r_value;
            A[r_value][j] = i;
        }
    }
    if ( n & 1 )            /* 若是 n 为奇数，消除虚拟的选手 */
    {
        for (int i = 1; i <= 2 * m; i++)
        {
            for (int j = 1; j <= days; j++)
                if (A[i][j] == n + 1)
                    A[i][j] = 0;        /* A[i][j] = 0 ,表示 i 号选手在第 j 天没有比赛 */
        }
    }
}

/* 分治求解循环赛问题 */
void tournament(int n)
{
    if (n <= 1)
        return;
    else if (n == 2)        /* 2 个选手 */
    {
        A[1][1] = 2;
        A[2][1] = 1;
    }
    else
    {
        tournament((int)ceil(n / 2.0));
        merge(n);
    }
}

/* 打印循环赛日程表 */
void show_result(int n)
{
    cout << " " << n << "人循环赛" << endl;
    int days = n&1 ？n : n-1;
    cout.flags(ios::left);
    cout << setw(8) << "";
    for (int i = 1; i <= n; i++)
        cout << setw(2)<<i << "号";
    cout << endl;
    cout.flags(ios::left);
    for (int j = 1; j <= days; j++)
    {
        cout << "第"<<setw(2)<<j<< "天 ";
        for (int i = 1; i <= n; i++)
        {
            cout << setw(4) << A[i][j];
        }
        cout << endl;
    }
    cout << endl;
}

int main()
{
    int num;
    while(true){
        cout << "请输入参赛人数（小于100）：(0结束程序）";
        cin >> num;
        if(num == 0) break;
        tournament(num);
        show_result(num);      
    }
    return 1;
}
复制代码

算法复杂度

设n=2^k，第i次循环须要计算(2^k/2ⁱ)²，2≤i≤k,总共的计算次数粗略的表示为 1²+2² +...+ 2^2j + ... + 2^2(k-1) 等比数列求和为(2^2k-1)/3，粗略等于2^2k=n^2。 因此算法时间复杂度为O(n^2).

因为只须要一个数组，因此空间代价为:O(n^2)