每对顶点间的最短距离——floyd算法

    Floyd算法用来找出每对顶点之间的最短距离，它对于图的要求是，可以是无向图也可以是有向图，边权可正可负，唯一的要求是不能有负环。 

时间复杂度  o(n²)

    Floyd算法基于动态规划的思想，以u到v的最短路径至少经过前k个点为转移状态进行计算，通过k的增加达到寻找最短路径的目的。当k增加1时，最短路径要么不变，如果改变，必定通过第k个点，也就是说当起点u到第k个点的最短路径加上第k个点到终点v的最短路径小于不经过第k个点的最优最短路径长度的时候，更新u到v的最短路径。当k=n时，u到v的最短路径就确定了。Flody算法的最短路径同Dijkstra算法一样采用倒查方式输出。

//根据HDU1874
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define maxn 1010
#define INF 0x3f3f3f3f
int n,m,a,b,c,s,e,sum,k,k1;
int map[maxn][maxn],pre[maxn],dist[maxn],lj[maxn];
struct stu
{
     int from,to,w;
}p[maxn];

void add(int x,int y,int w)
{
     p[sum].from=x;
     p[sum].to=y;
     p[sum++].w=w;
}

void bellman(int s,int e)
{
     for(int i=0;i<=n;i++)
     {
       dist[i]=INF;
       pre[i]=s;
     }
     pre[s]=-1;
     dist[s]=0;
     for(int i=0;i<n-1;i++)
     {
          for(int j=0;j<sum;j++)
          {
               int u=p[j].from;
               int v=p[j].to;
               int w=p[j].w;
               if(dist[v]>dist[u]+w)
               {
                    dist[v]=dist[u]+w;
                    pre[v]=u;
               }
          }
     }
//          for(int j=0;j<sum;j++)
//           {
//            int u=edge[j].from;
//            int v=edge[j].to;
//            int w=edge[j].w;
//            if(dist[u]>dist[u]+w)
//             return false;
//           }
//            return true;
}
int main()
{
     while(scanf("%d%d",&n,&m)!=EOF)
     {
          for(int i=0;i<=n;i++)
          for(int j=0;j<=n;j++)
          map[i][j]=map[j][i]=INF;
          memset(lj,0,sizeof(lj));
          sum=0;
          for(int i=0;i<m;i++)
          {
               scanf("%d%d%d",&a,&b,&c);
               if(c<map[a][b])
               {
                    map[a][b]=map[b][a]=c;
                    add(a,b,c);
                    add(b,a,c);
               }
          }
          scanf("%d%d",&s,&e);
          bellman(s,e);
          k=e;
          k1=0;
          lj[k1++]=e;
          while(pre[k]!=-1)
          {
               lj[k1++]=pre[k];
               k=pre[k];

          }

          printf("%d",s);
          for(int i=k1-2;i>=0;i--)
          printf("->%d",lj[i]);
          printf("\n");

          if(dist[e]==INF)
          printf("-1\n");
          else
          printf("%d\n",dist[e]);
     }
     return 0;
}