poj 2139 floyd算法

                                                        Six Degrees of Cowvin Bacon

时间限制:1000MSA一百一十一内存限制:65536KBA一百一十一64位输入输出格式:%I64d & %I64u

提交 状态 实践 POJ 2139

描述

The cows have been making movies lately, so they are ready to play a variant of the famous game "Six Degrees of Kevin Bacon".

The game works like this: each cow is considered to be zero degrees of separation (degrees) away from herself. If two distinct cows have been in a movie together, each is considered to be one 'degree' away from the other. If a two cows have never worked together but have both worked with a third cow, they are considered to be two 'degrees' away from each other (counted as: one degree to the cow they've worked with and one more to the other cow). This scales to the general case.

The N (2 <= N <= 300) cows are interested in figuring out which cow has the smallest average degree of separation from all the other cows. excluding herself of course. The cows have made M (1 <= M <= 10000) movies and it is guaranteed that some relationship path exists between every pair of cows.

输入

* Line 1: Two space-separated integers: N and M

* Lines 2..M+1: Each input line contains a set of two or more space-separated integers that describes the cows appearing in a single movie. The first integer is the number of cows participating in the described movie, (e.g., Mi); the subsequent Mi integers tell which cows were.

输出

* Line 1: A single integer that is 100 times the shortest mean degree of separation of any of the cows.

样例输入

4 2
3 1 2 3
2 3 4

样例输出

100

牛，如果cow_i 和cow_j干同一件工作，那么cow_i和cow_j的分离度就是1，如果cow_i和cow_j分别与cow_k工作，但是cow_i和cow_j不干同样的工作，那么cow_i和cow_j的分离度就是2，也就是说这种关系是可传递的，并且一次递增，要求找出一个cow_res，他和其他的cow的分离度的和是所有其他cow的分离度和的最小值，mmin = min{dist[cow_i]},注意结果的形式int(res)才可以，看了discuss才知道，算法就明了了，就是求所有的cow_i和cow_j的距离——floyd算法。

#include<stdio.h>
#include<string.h>
int map[305][305];
int n,m;
int init()
{
      int i,j,k;
      for(k=1;k<=n;k++)
      for(i=1;i<=n;i++)
      for(j=1;j<=n;j++)
      {
          if(map[i][k]!=0 && map[k][j]!=0 && (map[i][j]==0 || map[i][k]+map[k][j]<map[i][j])) //如果是0的话，说明有传递，所以直接赋值
          map[i][j]=map[i][k]+map[k][j];
      }
     return 0;   
}
int main()
{
    
    while(~scanf("%d%d",&n,&m))
    {
        memset(map,0,sizeof(map));
        int i,j,u,h;
        int a[n];
        for(i=1;i<=m;i++)
        {
            scanf("%d",&u);
            for(j=1;j<=u;j++)
            {
                scanf("%d",&a[j]);
            }
            for(j=1;j<=u;j++)
            {
                for(int o=1;o<=u;o++)
                {
                    map[a[o]][a[j]]=map[a[j]][a[o]]=1;
                }
            }
        }
        init();
        int sum;
        int min=0x3f3f3f3f;
        for(i=1;i<=n;i++)
        {
            sum=0;
            for(j=1;j<=n;j++)
            if(i!=j)
            sum+=map[i][j];
            min=sum<min?sum:min;
        }
        printf("%d\n",(int)100*min/(n-1));
    }
    return 0;
}