Floyd-Warshall算法

Floyd-Warshall算法（Floyd-Warshall algorithm）是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题。

Floyd-Warshall算法的时间复杂度为O(N³)，空间复杂度为O(N²)。

原理

Floyd-Warshall算法的原理是动态规划。

设D_i,j,k为从i到j的只以(1..k)集合中的节点为中间节点的最短路径的长度。

1. 若最短路径经过点k，则D_i,j,k = D_{i,k,k − 1} + D_{k,j,k − 1}；
2. 若最短路径不经过点k，则D_i,j,k = D_{i,j,k − 1}。

因此，D_i,j,k = min(D_{i,k,k − 1} + D_{k,j,k − 1},D_{i,j,k − 1})。

在实际算法中，为了节约空间，可以直接在原来空间上进行迭代，这样空间可降至二维。（见下面的算法描述）

算法描述：

Floyd-Warshall算法的描述如下：

for k ← 1 to n do
  for i ← 1 to n do
    for j ← 1 to n do
      if (Di,k + Dk,j < Di,j) then
        Di,j ← Di,k + Dk,j; 

其中D_i,j表示由点i到点j的代价，当D_i,j为 ∞ 表示两点之间没有任何连接。 

我自己写了代码如下：

#define M_A_X 300000
#define  M 4
int graph[M][M];
void floyd(int g[M][M],int D[M][M])
{
    for(int k = 0;k<M;k++)
        for(int i = 0;i<M;i++)
        {
            for(int j = 0;j<M;j++)
            {
                if(k == 0)
                    D[i][j] =g[i][j];
                else
                {
                    D[i][j] = MIN(D[i][j],D[i][k]+D[k][j]);
                }
            }
        }
}
void printgraph(int g[M][M],int v)
{
    for(int i = 0;i<v;i++)
    {
        for (int j = 0;j<v;j++)
        {
            if(g[i][j] == M_A_X)
                cout<<"*"<<" ";
            else
                cout<<g[i][j]<<" ";
        }
        cout<<endl;
    }
    cout<<endl;
}
void main()
{
    int g[M][M]={{0,1,M_A_X,M_A_X},{M_A_X,0,2,M_A_X},{M_A_X,M_A_X,0,3},{4,M_A_X,M_A_X,0}};
    printgraph(g,M);
    floyd(g,graph);
    printgraph(graph,M);
}

文章转自：http://www.cnblogs.com/davidluo/articles/1799811.html