单循环赛贝格尔编排法实现

最新推荐文章于 2024-09-14 20:30:05 发布

Motongxue

最新推荐文章于 2024-09-14 20:30:05 发布

阅读量6.2k

点赞数 3

分类专栏：算法文章标签：算法

原文链接：https://blog.csdn.net/windpenguin/article/details/62038377

版权

算法专栏收录该内容

8 篇文章 1 订阅

订阅专栏

原文链接
单循环赛，是指所有参赛队伍都需跟其他队伍比赛一次，根据比赛得分，胜负场次来排列名次。比赛队伍为单数时，轮数等于队伍数，为双数时，轮数等于队伍数减一。如5支队伍需比赛5轮，6支队伍需比赛5轮。

首先介绍下逆时针轮转法。将队伍用阿拉伯数字从1开始编号，编排时将参赛队伍平均分成左右两排，左边从1开始自上向下排，右边按号数自下向上排，形成一个U型结构。如果队伍数为奇数，则在最后加一个“0”，凑成偶数。与0比赛的队伍该轮轮空。假设现在有7支队伍参赛，加上一个0，凑成8支。根据前面所述排列好队伍，然后将左右两排分别平行连线，就形成第一轮比赛的编排表，即1-0，2-7，3-6，4-5，队伍1在该轮轮空。第二轮开始，固定左上角的数字1，其余的数字想象成一个环，按逆时针方向移动一个位置，就形成第二轮的编排表。以此类推，每一轮移动一个位置，生成剩余轮次的编排表。最终形成的编排表如下：

一二三四五六七

1—0 1—7 1—6 1—5 1—4 1—3 1—2

2—7 0—6 7—5 6—4 5—3 4—2 3—0

3—6 2—5 0—4 7—3 6—2 5—0 4—7

4—5 3—4 2—3 0—2 7—0 6—7 5—6

仔细观察，会发现从第4轮开始，队伍6总是跟上一轮轮空的队伍比赛，这就是逆时针轮转法的缺点，即第二轮的轮空队从第四轮开始，每轮都与前一轮的轮空队伍比赛。

贝格尔编排法与逆时针轮转法类似，不过有两个区别。一是交替固定最大的数字（或者0）在左上角和右上角，当前轮次在左上角，则下一轮固定到右上角。二是固定最大数字（或者0）后，剩余的数字想象成一个环，移动一定间隔，这个间隔根据队伍数决定：

队伍数间隔数

<=4 0

5 - 6 1

7 - 8 2

9 -10 3

11-12 4

13-14 5

… …

假设有n（n>=4）支队伍参赛，则间隔数的计算公式为(n+n%2-4)/2。

同样以7支队伍参赛为例，首轮还是

1 - 0

2 - 7

3 - 6

4 - 5

第二轮将0移到左上角，剩下的数字从1开始逆时针移动2个间隔，这里1将移到原来4所在的位置

第三轮将0移动到右上角，剩下的数字继续逆时针移动2个间隔

剩下的轮次原理同上，最终编排表如下

代码实现的思路如下，最大数字的位置只需根据前一轮的位置就能确定，其他数字都是按顺序排列，形成一个有序的环。所以只需要确定1的位置，其他位置的数字都能确定。将位置按照第一轮的数字编号为1-8。在第一轮，1在位置1上。第二轮，1移动2个间隔，可以理解成移动3个位置，即1+3=4，取模一下，(1+3)%7=4，所以1将移到位置4。第三轮，继续移动3个位置，(4+3)%7=0，这里0就是7，也就是1移到位置7。第四轮，(7+3)%7=3，1移到位置3。以此类推。要注意的是，要是1移到的位置跟0冲突，就移到相对位置。0在位置8，那么1就移到位置1，0在位置1，1就移到位置8。

运行效果

在这里插入图片描述

代码实现

#include <iostream>
using namespace std;
void BegerArrangement(int nAmount)
{
    if (nAmount < 2 || nAmount > 90)
        return;
    // 队伍数量
    int nFixAmount = nAmount;
    // 最后一支队伍的编号
    int nLastPlayerNo = nAmount;
    // 奇数队伍，补上一支虚拟的队伍，最后一支队伍的编号为0
    if (nAmount % 2)

    {
        ++nFixAmount;
        nLastPlayerNo = 0;
    }
    // 轮数
    int nMaxRound = nFixAmount - 1;
    int nHalfAmount = nFixAmount / 2;
    // 移动的间隔
    int nStep = nFixAmount <= 4 ? 1 : (nFixAmount - 4) / 2 + 1;
    int nRound = 1;
    int nFirstPlayerPos = 1;
    int nLastPlayerPos = 1;
    int result[100][200] = {0};
    while (nRound <= nMaxRound)

    {
        // 每次最后一个玩家的位置需要左右对调
        nLastPlayerPos = nFixAmount + 1 - nLastPlayerPos;
        if (nRound == 1)
            nFirstPlayerPos = 1;
        else
            nFirstPlayerPos = (nFirstPlayerPos + nStep) % (nFixAmount - 1);
        if (nFirstPlayerPos == 0)
            nFirstPlayerPos = nFixAmount - 1;
        if (nFirstPlayerPos == nLastPlayerPos)
            nFirstPlayerPos = nFixAmount + 1 - nLastPlayerPos;
        for (int i = 1; i <= nHalfAmount; ++i)

        {
            int nPos[2] = {i, nFixAmount - i + 1};
            int nPlayer[2] = {0, 0};
            for (int j = 0; j < 2; ++j)

            {
                if (nPos[j] == nLastPlayerPos)
                    nPlayer[j] = nLastPlayerNo;
                else if (nPos[j] < nFirstPlayerPos)
                    nPlayer[j] = nFixAmount - nFirstPlayerPos + nPos[j];
                else
                    nPlayer[j] = nPos[j] - nFirstPlayerPos + 1;
                result[i - 1][(nRound - 1) * 2 + j] = nPlayer[j];
            }
        }
        ++nRound;
    }
    for (int i = 1; i <= nMaxRound; ++i)

    {
        if (i == 1)
            printf("%3s%-3d|", "r", i);
        else
            printf("%4s%-3d|", "r", i);
    }
    printf("\n");
    for (int i = 0; i < nHalfAmount; ++i)

    {
        for (int j = 0; j < nMaxRound; ++j)

        {
            printf("%-2d-%2d | ", result[i][j * 2], result[i][j * 2 + 1]);
        }
        printf("\n");
    }
    printf("\n\n");
}
int main()
{
    int n;
    cin >> n;
    BegerArrangement(n);
    return 0;
}