POJ3660cow contest(floyd求传递闭包）

最新推荐文章于 2021-08-06 22:28:19 发布

偷吃了老鼠的土豆

最新推荐文章于 2021-08-06 22:28:19 发布

阅读量96

点赞数

分类专栏：图论-最短路

本文链接：https://blog.csdn.net/guagua_de_xiaohai/article/details/81082979

版权

图论-最短路专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Cow Contest

N (1 ≤ N ≤ 100) cows, conveniently numbered 1..N, are participating in a programming contest. As we all know, some cows code better than others. Each cow has a certain constant skill rating that is unique among the competitors.

The contest is conducted in several head-to-head rounds, each between two cows. If cow A has a greater skill level than cow B (1 ≤ A ≤ N; 1 ≤ B ≤ N; A ≠ B), then cow A will always beat cow B.

Farmer John is trying to rank the cows by skill level. Given a list the results of M(1 ≤ M ≤ 4,500) two-cow rounds, determine the number of cows whose ranks can be precisely determined from the results. It is guaranteed that the results of the rounds will not be contradictory.

Input

* Line 1: Two space-separated integers: N and M
* Lines 2..M+1: Each line contains two space-separated integers that describe the competitors and results (the first integer, A, is the winner) of a single round of competition: A and B

Output

* Line 1: A single integer representing the number of cows whose ranks can be determined
　

Sample Input

Sample Output

题意：有N头牛，每一头牛都可被另外的牛打败，也可以打败其他的牛，如果A牛可打败B牛，且B牛可打败C牛，则说明A牛也可打败C牛，那么A牛和C牛的等级就确定了。让你确定总共有多少头牛的等级可以确定。

分析：利用Floyd求出传递闭包，如果有的牛之间可间接被打败，也就相当于放到图里边节点之间可间接到达，也可确定两者的等级。而每一头牛都是要么打败别的牛，要么被别的牛打败，而他打败的牛的数目，和打败他的牛的数目加起来刚好等于N-1，那么他的等级就确定了。而求传递闭包不需要考虑路径长短，只需要确定有没有路即可，如果有就设为1，没有就设为0。

Floyd求传递闭包算法核心：

  for(int k=1;k<=N;k++)
        for(int i=1;i<=N;i++)
        for(int j=1;j<=N;j++)
        edge[i][j]=edge[i][j]||(edge[i][k]&&edge[k][j]);

核心代码：

#include <iostream>
#include <string.h>
#define MAX 105
using namespace std;

int main()
{
    int N,M;
    cin>>N>>M;
    int A,B;
    int edge[MAX][MAX];
    memset(edge,0,sizeof(edge));
    for(int i=0;i<M;i++)
    {
        cin>>A>>B;
        edge[A][B]=1;
    }
    for(int k=1;k<=N;k++)
        for(int i=1;i<=N;i++)
        for(int j=1;j<=N;j++)
        edge[i][j]=edge[i][j]||(edge[i][k]&&edge[k][j]);
    int cot,T=0;
    for(int i=1;i<=N;i++){
            cot=0;
            for(int j=1;j<=N;j++)
            {
                if(edge[i][j])
                    cot++;
                if(edge[j][i])
                    cot++;
            }
            if(cot==N-1)
                T++;
    }
    cout<<T<<endl;
    return 0;
}