石油大2018年第四阶段组队训练赛第二场 D

最新推荐文章于 2022-08-22 14:56:31 发布

原创最新推荐文章于 2022-08-22 14:56:31 发布 · 358 阅读

0 ·

CC 4.0 BY-SA版权

dfs 专栏收录该内容

4 篇文章

订阅专栏

探讨了一种单场循环赛制下，如何通过编写程序计算导致所有参赛队伍进入全季后赛的剩余比赛赢/输组合模式数量的问题。该程序采用深度优先搜索策略，确保各队伍胜负次数相等。

问题 D: Playoff

时间限制: 2 Sec 内存限制: 128 MB
提交: 181 解决: 59
[提交] [状态] [讨论版] [命题人:admin]

题目描述

The Minato Mirai Football Association hosts its annual championship as a single round-robin tournament, in which each team plays a single match against all the others. Unlike many other round-robin tournaments of football, matches never result in a draw in this tournament. When the regular time match is a tie, overtime is played, and, when it is a tie again, a penalty shootout is played to decide the winner.
If two or more teams won the most number of matches in the round-robin, a playoff is conducted among them to decide the champion. However, if the number of teams is an odd number, it is possible that all the teams may have the same number of wins and losses, in which case all the teams participate in the playoff, called a "full playoff" here.
Now, some of the tournament matches have already been played and we know their results. Whether or not a full playoff will be required may depend on the results of the remaining matches. Write a program that computes the number of win/loss combination patterns of the remaining matches that lead to a full playoff.
The first datatset of the Sample Input represents the results of the first three matches in a round-robin tournament of five teams, shown in the following table. In the table, gray cells indicate the matches not played yet.

In this case, all the teams win the same number of matches with only two win/loss combination patterns of the remaining matches, which lead to a full playoff, as shown below. In the two tables, the differences are indicated in light yellow.

输入

The input consists of multiple datasets, each in the following format.
n
m
x1 y1
...
xm ym
n is an odd integer, 3, 5, 7, or 9, indicating the number of teams participating in the tournament. m is a positive integer less than n(n−1)/2, which is the number of matches already finished. xi and yi give the result of the i-th match that has already taken place, indicating that team xi defeated team yi. Each of xi and yi is an integer 1 through n which indicates the team number. No team plays against itself, that is, for any i, xi ≠ yi. The match result of the same team pair appears at most once. That is, if i ≠ j, then (xi,yi) ≠ (xj,yj) and (xi,yi) ≠ (yj,xj) hold.

The end of the input is indicated by a line containing a zero. The number of datasets does not exceed 100.

输出

For each dataset, output a single line containing one integer which indicates the number of possible future win/loss patterns that a full playoff will be required.

样例输入

样例输出

大意：Minato Mirai足球协会将其年度锦标赛作为单场循环赛举办，每场比赛对阵所有其他球队。与许多其他的橄榄球循环赛不同，比赛从未在本次比赛中获得平局。当常规时间比赛是平局时，将播放加时赛，并且当再次打平时，将进行点球大战以决定胜者。
如果两支或更多球队在循环赛中赢得了最多的比赛，那么他们之间会进行一场季后赛以决定冠军。但是，如果球队的数量是一个奇数，那么所有球队都可能拥有相同数量的胜负，在这种情况下，所有球队都参加了季后赛，在这里称为“全季后赛”。
现在，一些锦标赛比赛已经开始，我们知道他们的结果。是否需要完整的季后赛可能取决于剩余比赛的结果。编写一个程序，计算导致完整季后赛的剩余比赛的赢/输组合模式的数量。

思路感觉是个搜索题
设mpp[a][b]表示a击败b，win[i]表示第i只队伍赢了几次

lose[i]表示第i只队伍输了几次
然后搜索
1.每只队伍赢得次数相等那就是(n-1)/2
2.然后搜索试试

3.每次搜索要把lose[i]>(n-1)/2和win[i]>(n-1)/2的减掉

代码:

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

int n,m;
int a[1000][1000];
int win[1000];
int lose[1000];
int ans;
void dfs(int x,int y)
{
    if(x == n && y == n)//判断结束
    {
        ans++;
        return;
    }

    if(y > n ) // 超限
    {
        x++;
        y = 1;
    }

    if(a[x][y]!= -1 || x==y ) // 有结果的情况
    {
        dfs(x,y+1);
    }

    else
    {
        if(win[x] < (n-1)/2 && lose[y] < (n-1)/2) // 赢
        {
            a[x][y] = 1;
            a[y][x] = 0;
            win[x]++;
            lose[y]++;
            dfs(x,y+1);
            a[x][y] = -1;
            a[y][x] = -1;
            win[x]--;
            lose[y]--;
        }
        if(lose[x] < (n-1)/2 && lose[x] < (n-1)/2) //输
        {
            a[x][y] = 0;
            a[y][x] = 1;
            win[y]++;
            lose[x]++;
            dfs(x,y+1);
            a[x][y] = -1;
            a[y][x] = -1;
            win[y]--;
            lose[x]--;
        }
    }
}

int main()
{
    int w,l;
    while(scanf("%d%d",&n,&m)!=EOF && n)
    {
        int flag = 0;ans = 0;
        memset(a,-1,sizeof(a));
        memset(win,0,sizeof(win));
        memset(lose,0,sizeof(lose));
        for(int i = 1; i <= m ;i++) 
        {
           scanf("%d%d",&w,&l);
           a[w][l] = 1;
           a[l][w] = 0;
           win[w]++;
           lose[l]++;
        }
        for(int i = 1 ;i <= n ;i++) // 在比赛前先判断一下
        {
            if(win[i] > (n-1)/2)
            {
                flag = 1;
                printf("0\n");
                break;
            }
            if(lose[i] > (n-1)/2)
            {
                flag = 1;
                printf("0\n");
                break;
            }
        }
        if(!flag)
        {
            dfs(1,1);
            printf("%d\n",ans);
        }
    }
}