分治策略之循环赛
一、实验题目
•设有n个运动员要进行网球循环赛。设计一个满足下列条件的比赛日程表：
–每个选手必须与其他n-1个选手各赛一次；
–每个选手一天只能赛一次；
–当n是偶数时，循环赛进行n-1天。
–当n是奇数时，循环赛进行n天。
二、实验目的及其实验要求
1、使用分治策略，编写程序完成以上实验题目。
2、设置数据集，测试程序，写出测试报告。
3、验证算法的正确性。
4、写出题目的具体分析过程，算法程序进行必要的解析（伪代码+源代码）。
5、分析所完成程序的时间复杂度。
三、实验步骤
一、题目分析
在课堂上，我们已经学习过了，对于2k这种幂次数量的比赛选手，可以直接二分，对调位置得到结果。
完全使用分治策略，问题规模最小是2，可以直接构建比赛集，然后合并，就是将本模块，挪动到对角线位置，构成新的一个整体模块。
这种方法是非常特殊，因为是幂次，所以大大降低了难度，不在此赘余，下面我将这种特殊情况，扩展到更一般情况，n可以是任意整数。
n位奇数时，比赛天数为n天，意味着，每个运动员都有一天的休息时间。
n位偶数时，比赛天数为n-1天，每个运动员每天都有比赛。
首先从基本入手，使用脑算，计算运动员的比赛规则表
（1） n=2
比赛只需要1天，比赛表如上
（2）n=3
比赛的总时间是3天，在这三天中，每个运动员都有一天的休息时间，并且他们每个人的休息时间都不在同一天。
（3）n=4
比赛总天数是3天，4=2+2，分成单独的两个队伍，队伍内先比赛，然后每个队员与另一个队伍中的每个运动员比赛。
（对比n=4和n=3，可以发现，n=4这一行删除，并且把表格中的4删除，就得到了表格n=3）
（4）n=5
比赛的总天数是5天，此时已经发现，没有前几个n比较小的时候容易写了，我们必须使用有效的策略。
n=5规模对于我来说太大了，先跳过吧。
（5）n=6
分成两组 3+3，每一组比赛的时间时3天，合并两组需要3天，总共6天。如何减少一天呢？
两组三天内的比赛，我们看到这是两组一模一样的表，1和4，2和5，3和6都有在相同时间在休息。让他们把空闲的时间利用起来。
然后两组合并。
此时剩下两天需要完成的比赛：
1：5、6
2：4、6
3：4、5
第四天
1vs5 2vs6 3vs4
第五天
1vs6 2vs4 3vs5
完成赛表。
这时，我们在考虑n=5，就简单多了，直接把第6行删除，然后把表格中的6也删除就OK了。
（6）n=7
在n=8的基础上删减得到。
（7）n=8
略，太简单了，见以上第一个图。
（8）n=9依托于n=10的计算。
n=10可以分成5+5，两个形状完全一样的表格，填补。然后在根据一定的算法进行补充后面的4天的表格。
以上，我们可以得到规律，就是对于n=2k，通过适当的删除，我们可以直接得到n=2k-1的比赛表。
而n=2k时可以考虑为n+n两组合并来求。
此时，我们需要对合并算法，进行探究。
再以n=6为例
简单填补后得到前三天的比赛表。
在接下来的2天，还需要完成的比赛
运动员1： 5、6
运动员2：4、6
运动员3：4、5
第四天
运动员1选了5（从小到大），那么运动员2选6（ 5+1 ） ，从下一位开始，运动员3选4（7-3）。
第五天
运动员1选了6，运动员2选4（7-3），运动员3选5（8-3）
完毕。
n=10
5+5
对于n=5的表格，我们已经在上述得到，对n=6进行掏空就行。
首先填补对应位置空闲时间，得到如下表格，是前5天的比赛表。
在接下来的4天时间，需要比赛。
运动员1：7、8、9、10
运动员2：6、8、9、10
运动员3：6、7、9、10
运动员4：6、7、8、10
运动员5：6、7、8、9
第6天
7、8、9、10、6
第7天
8、9、10、6、7
第8天
9、10、6、7、8
第9天
10、6、7、8、9
总表如下
因此这个n=10的情况也得到了。
以每组首个运动员第一个需要比赛的运动员为起点，形成一个环。
观察下面两图，可以看到规律。
下面，我将以上规律进行推广。
设f(m~n)表示对m~n个运动员比赛表的生成。
例如n=50
使用分治策略，分别是f(1~25)和f(26~50)，这两个长得基本一样，第二个表就是对第一个表中所有数字+25。因此问题分治成求f(1~25)，然后和f(26~50)合并。
以下是这个问题的递和归过程。
step 1: f(1~50) → f(1~25) U f(26~50) step 18: 输出结果，结束。
step 2: f(1~25) → f(1~26) - f(26) step 17: 根据f(1~25)直接写出f(26~50)，合并为f(1~50)
step 3: f(1~26) → f(1~13) U f(14~26) step 16: f(1~26)删减为f(1~25)
step 4: f(1~13) → f(1~14) - f(14) step 15: 根据f(1~13)直接写出f(14~26)，合并为f(1~26)
step 5: f(1~14) → f(1~7) U f(8~14) step 14: f(1~14)删减为f(1~13)
step 6: f(1~7) → f(1~8) - f(8) step 13: 根据f(1~7)直接写出f(8~14)，合并为f(1~14)
step 7: f(1~8) → f(1~4) U f(4~8) step 12: f(1~8)删减为f(1~7)
step 8: f(1~4) → f(1~2) U f(3~4) step 11: 根据f(1~4)直接写出f(5~8)合并为f(1~8)
step 9: 直接计算 f(1~2)，根据f(1~2)直接写出f(3~4) step 10: 合并 f(1~2) f(3~4) 得到 f(1~4)
n可以扩展所有可计算范围。
当n为奇数时，通过计算f(n+1)，然后删减得到
当n为偶数时，二分，只计算前半部分，后半部分，可以直接“抄袭”前半部分😁
接下来是合并算法，根据上面的处理情况得知，前半部分和后半部分永远是等大的（因为采取二分策略的时候n是偶数）。
当半个部分大小size是偶数时，可以直接复制到对角线就OK。
当半个部分大小size是奇数的，稍微困难一点，但是还是有规律可循。
首先，两个部分都在相同的位置存在空闲，因此让对应部分相互比赛，如下图
首先填补前5天的空闲时间后得到
然后填充后4天的表格，我填写情况如下
我们只需填写1~5号运动员，那么对应的6~10号运动员也就直接填写完毕。
看第6~9天，纵方向看
可以发现，就是 7 8 9 10 6围成了一个环，后面的时间都是从前一个的头结点的下一个为头节点，开始循环。
所以我们只需要找到第六天的头就行了，第六天的头是7=1+6（我们看到其实第一排是有序的1~10），所以算法分析到此结束。
你看懂了吗😝
二、代码实现
1) 伪代码
void raceTable(int left,int right) //待求的左边界和右边界
{
if(size==2)
{
填表格，结束
}
if(size为奇数)
{
计算 raceTable(pos,size+1);
}
else{
raceTable(pos,size/2); //分治策略，计算前半部分
copyTable(pos,right); //根据上式前半部分的计算，直接写出后半部分。
Union(pos,size/2);//合并两部分
}
}
void Union(int left,int mid,int right)
{
if(mid为奇数)
两组相对于，填补前n天的空闲时间;
循环左下边放入到右上角，同时放置对应的右下角（同时进行的）
}
void copyTable(pos,right)
实现c++代码
2）分模块完成代码
a) 生成比赛表函数
void raceTable(int left,int right)
{
int size=right-left+1;
if(size==2) //递归终点
{
arr[left][1]=right;
arr[right][1]=left;
return;
}
if(size%2==1) //当前计算规模是奇数，我们计算大一个规模
{
raceTable(left,right+1);
return;
}
//以下是size是2的倍数
int mid=(left+right)/2;
raceTable(left,mid);
copyTable(left,mid,right); //直接复制上面计算得到的
Union(left,mid,right);
}
b) copyTable函数，根据前半部夫直接抄写后半部分。
void copyTable(int left,int mid,int right) //复制函数
{
int size=right-left+1;
int i,j,m;
if(size%2==1) //奇数
m=size;
else
m=size-1;
for(i=right;i>mid;i--)
for(j=1;j<=m;j++)
arr[i][j]=arr[i-mid][j]+mid;
}
c) 合并函数，将前半部夫和后半部分合并
void Union(int left,int mid,int right)
{
int i,j;
int size=right-left+1;
if(mid%2==1) //如果size为奇数，需要首先填补前几天的空白
{
for(i=left;i<=mid;i++)
for(j=1;j<=size;j++)
{
if(arr[i][j]>mid) //这个位置是空的
{
arr[i][j]=i+mid;
arr[i+mid][j]=i;
break;
}
}
}
//下面开始合并
if(mid%2==0) //每一半都是偶数，直接移到对角线
{
for(j=mid;j<right;j++)
for(i=1;i<=mid;i++)
{
int t=arr[i+mid][j-mid];
arr[i][j]=t;
arr[t][j]=i;
}
}
else{
//结合规律，开始合并
for(j=mid+1;j<right;j++)
for(i=1;i<=mid;i++)
{
int t=i+j;
if(t>right)
t-=mid;
arr[i][j]=t;
arr[t][j]=i;
}
}
}
//需要将arr的0位置初始化，以便来完成上述移动
for(int i=1;i<=n;i++)
arr[i][0]=i;
3) 完全源代码
#include <iostream>
#include <cstdio>
using namespace std;
const int maxn=1005;
int arr[maxn][maxn]={0};
int n;
bool isCorrect()
{
int i,j;
int days;
if(n%2==0)
days=n-1;
else
days=n;
bool isAppearence[n+1];
for(i=1;i<=n;i++) //行
{
fill(isAppearence,isAppearence+n+1,false); //初始化数组
for(j=1;j<=days;j++)
{
int t=arr[i][j];
if(t==0)
continue;
if(isAppearence[t]) //在这一行中之前已经出现过了
return false;
isAppearence[t]=true;
if(arr[t][j]!=i || t>n || t<1 ) //选手t在第j天的对手必须是i,t必须是正确选手1~n
return false;
}
}
return true;
}
void Union(int left,int mid,int right)
{
int i,j;
int size=right-left+1;
if(mid%2==1) //如果size为奇数，需要首先填补前几天的空白
{
for(i=left;i<=mid;i++)
for(j=1;j<=size;j++)
{
if(arr[i][j]>mid) //这个位置是空的
{
arr[i][j]=i+mid;
arr[i+mid][j]=i;
break;
}
}
}
//下面开始合并
if(mid%2==0)
{
for(j=mid;j<right;j++)
for(i=1;i<=mid;i++)
{
int t=arr[i+mid][j-mid];
arr[i][j]=t;
arr[t][j]=i;
}
}
else{
//结合规律，开始合并
//size=6 mid=3 left=1 right=6
for(j=mid+1;j<right;j++)
for(i=1;i<=mid;i++)
{
int t=i+j;
if(t>right)
t-=mid;
arr[i][j]=t;
arr[t][j]=i;
}
}
}
void copyTable(int left,int mid,int right) //复制函数
{
int size=right-left+1;
int i,j,m;
if(size%2==1) //奇数
m=size;
else
m=size-1;
for(i=right;i>mid;i--)
for(j=1;j<=m;j++)
arr[i][j]=arr[i-mid][j]+mid;
}
void raceTable(int left,int right)
{
int size=right-left+1;
if(size==2)
{
arr[left][1]=right;
arr[right][1]=left;
return;
}
if(size%2==1)
{
raceTable(left,right+1);
return;
}
//以下是size是2的倍数
int mid=(left+right)/2;
raceTable(left,mid);
copyTable(left,mid,right); //直接复制上面计算得到的
Union(left,mid,right);
}
int main() {
cin>>n;
for(int i=1;i<=n;i++)
arr[i][0]=i;
raceTable(1,n);
int t=n%2==0?n-1:n;
for(int i=1;i<=n;i++)
{
printf("%d: ",i);
for(int j=1;j<=t;j++)
{
if(arr[i][j]==n+1) //空闲时间
arr[i][j]=0;
printf(" %d",arr[i][j]);
}
printf("\n");
}
if(isCorrect())
cout<<"true"<<endl;
else
cout<<"false"<<endl;
return 0;
}
三、算法正确性测试
n为奇数，比赛在n天内完成；
n为偶数，比赛在n-1天内完成。
a) 对于每 i 行，1~n除了 i 必须都出现，并且只出现1次。
b) 如果某一天a和b比赛，那么也一定是b和a比赛，假如运动员a在第 i 天和b比赛，那么b在第 i 天也一定和a在进行比赛，因此需要验证
b=arr[a][i]
那么 arr[b][i]=a，否则报告错误
c) 每个运动员每天只能比赛一次，列表示为天数，那么每列每个运动员编号不能出现两次。
考虑到，如果某列一个运动员出现了不少于2次，而该运动员当天比赛的队伍的格子只能是一个队伍，这与b)矛盾，可以认为，如果不满足条件c)则一定不满足条件b)，因此可以不必判断c)。
d) 必须保证出现在表格中的运动员编号是有效的，即1~n，不是这个范围内的数则输出错误信息。
以下是判断算法正确性的代码
int n;
int arr[maxn][maxn];
bool isCorrect()
{
int i,j;
int days;
if(n%2==0)
days=n-1;
else
days=n;
bool isAppearence[n+1];
for(i=1;i<=n;i++) //行
{
fill(isAppearence,isAppearence+n+1,false); //初始化数组
for(j=1;j<=days;j++)
{
int t=arr[i][j];
if(t==0) //空闲时间的标志
continue;
if(isAppearence[t]) //在这一行中之前已经出现过了
return false;
isAppearence[t]=true;
if(arr[t][j]!=i || t>n || t<1 ) //选手t在第j天的对手必须是i,t必须是正确选手1~n
return false;
}
}
return true;
}
测试集：
对n取2~1000，使用上述测试算法，输出测试结果，确保全部输出为true。
{
int i;
for(i=2;i<=1000;i++)
{
fill(arr,arr+maxn*maxn,0);
raceTable(1,i);
if( isCorrect() )
printf("True\n");
else
printf("False\n");
}
}
输出结果为100个True。
四、算法时间复杂度分析
此题目是二维矩阵，对于n，很容易知道时间复杂度下限是Ω(n2)
分析我的代码
n为奇数 f(n) = f(n+1)
n为偶数 f(n) = f(n/2) + (n/2)×(n/2) + 2×(n/2)×(n/2)
因此可以递推得到时间复杂度是O(n2)
验证算法正确度时间复杂度O(n2)，就是对一个二维矩阵的枚举过程。
6083
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
