HDU-1869:六度分离（floyd(单源最短路，可处理负边，大数据容易超时)）

图论

• floyd算法小结（参考博客）

Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。Floyd-Warshall算法的时间复杂度为O($N^3$)，空间复杂度为O($N^2$)。

例题题面链接

• 题意

  Input
  本题目包含多组测试，请处理到文件结束。
  对于每组测试，第一行包含两个整数N,M(0 接下来有M行，每行两个整数A,B(0<=A,B 除了这M组关系，其他任意两人之间均不相识。

  Output
  对于每组测试，如果数据符合“六度分离”理论就在一行里输出"Yes"，否则输出"No"。

• 样例

  Sample Input
  8 7
  0 1
  1 2
  2 3
  3 4
  4 5
  5 6
  6 7
  8 8
  0 1
  1 2
  2 3
  3 4
  4 5
  5 6
  6 7
  7 0

  Sample Output
  Yes
  Yes

• 代码

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int i,j,k,n,m,edge[111][111],st,en,flag;
void init()
{
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
       {
           if(i==j)
            edge[i][j]=0;//自己到自己距离为0
           else
            edge[i][j]=0x3fffffff;
       }
}
void floyd()
{
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            for(k=0;k<n;k++)
            {
                if(edge[j][k]>edge[j][i]+edge[i][k])
                    edge[j][k]=edge[j][i]+edge[i][k];
            }
        }
    }
    for(i=0;i<n;i++)
        for(j=0;j<n;j++)
    {
        if(edge[i][j]>7)
            flag=1;
    }
    if(flag==0)
       printf("Yes\n");
    else
       printf("No\n");
}
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        init();
        flag=0;
        for(i=0;i<m;i++)//邻接矩阵存边
        {
            scanf("%d%d",&st,&en);
            if(st!=en&&edge[st][en]>1)
                edge[st][en]=edge[en][st]=1;
        }
        floyd();
    }
    return 0;
}
模板代码
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
int edge[101][101];
#define INFF 1e9+7;
int n,m;
void init()//初始化
{
    int i,j;
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            if(i==j)//自己到自己初始化为0
                edge[i][j]=0;
            else
                edge[i][j]=INFF;
}
void floyd()
{
    int i,j,k;
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            for(k=1;k<=n;k++)
                if(edge[j][k]>edge[j][i]+edge[i][k])
                    edge[j][k]=edge[j][i]+edge[i][k];
    for(i=1;i<=n;i++)
        for(j=i;j<=n;j++)
            printf("%d->%d=%d\n",i,j,edge[i][j]);
}
int main()
{
    int st,en,len;
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        init();
        while(m--)//邻接矩阵存边
        {
            scanf("%d %d %d",&st,&en,&len);
            if(st!=en&&edge[st][en]>len)//注意重边和自环
                edge[st][en]=edge[en][st]=len;
        }
        floyd();
    }
    return 0;
}