Floyd算法

Floyd算法是一种动态规划算法，用于求解有向图中每对顶点间的最短路径。它要求有向图中可以有负权值，但是不能有负的回路，和Dijkstra，Bellman-Ford算法一样，都是不能有负回路的。

设有向图G=(V,E)，采用邻接矩阵来表示每对顶点之间的距离d[i][j]。初始时，若i=j，则d[i][j]=0；若i和j之间直接相连,则d[i][j]=Weight(i,j)；若i和j之间不直接相连，则d[i][j]=正无穷 OR INT_MAX。

假设节点编号是1,2,3,,,,,,,n

现在要计算顶点<i,j>之间的最短路径，设<i,j>之间最短路径的中间节点的最大节点是k，即中间节点在(1,2,3,,,,k)的范围内，那么现在有2中情况

1。假设k是<i,j>最短路径的中间节点，那么<i,j>可以划分为<i,k>和<k,j>，因为<i,j>的中间节点在(1,2,3,,,,k)之间，并且最短路径是一条简单路径(节点没有重复的路径)，那么可以得出路径<i,k>和路径<k,j>的中间节点都在(1,2,3,,,,k-1)范围内，所以有d[i][j]=d[i][k]+d[k][j]并且k>=1&&k<=n

2。假设k不是<i,j>最短路径的中间节点，那么<i,j>的中间节点的范围是(1,2,3,,,,,k-1)，那么k时的d[i][j]等于k-1时的d[i][j]

所以，可以得到d[i][j]的值  

当k=0时，d[i][j](k=0)=Weight(i,j)

当k>=1时,d[i][j](k)=min(d[i][j](k-1)，d[i][k](k-1)+d[k][j](k-1))

所以，在初始化d[i][j]之后，就可以用下面的O(n^3)的算法来表示oyd算法

 for(k=1;k<=n;k++)

　　for(i=1;i<=n;i++)

　　 for(j=1;j<=n;j++)

　　  if(d[i][k]+d[k][j]<d[i][j])

         d[i][j]=d[i][k]+d[k][j];

 

给定1个有向无负回路图，有10个节点，下面是Floyd算法的具体实现

?

#include<iostream>

#include<climits>

using namespace std;

 

#define N 11

 

int dis[N][N];

int map[N][N];

int path[N][N];

 

void init(void)

{

    int i,j;

 

    for(i=1;i<N;i++)

        for(j=1;j<N;j++)

            if(i==j) map[i][j]=0;

            else         map[i][j]=INT_MAX;

 

    map[1][2]=2,map[1][4]=20,map[2][5]=1;

    map[3][1]=3,map[4][3]=8,map[4][6]=6;

    map[4][7]=4,map[5][3]=7,map[5][8]=3;

    map[6][3]=1,map[7][8]=1,map[8][6]=2;

    map[8][10]=2,map[9][7]=2,map[10][9]=1;

}

 

void floyd(void)

{

    int i,j,k;

     

    for(i=1;i<N;i++)

        for(j=1;j<N;j++)

        {

            dis[i][j]=map[i][j];   

            path[i][j]=0;

        }

 

    for(k=1;k<N;k++)

        for(i=1;i<N;i++)

            for(j=1;j<N;j++)

                if(dis[i][k]!=INT_MAX && dis[k][j]!=INT_MAX && (dis[i][k]+dis[k][j]<dis[i][j]))

                {

                    dis[i][j]=dis[i][k]+dis[k][j];

                    path[i][j]=k;

                }

}

 

void print(void)

{

    int i,j;

    for(i=1;i<N;i++)

    {

        for(j=1;j<N;j++)

            cout<<dis[i][j]<<" ";

        cout<<endl;

    }

     

}

 

int main(void)

{

    init();

    floyd();

    print();

    return 0;

}

矩阵打印出每对<i,j>节点的最短路径长度，另还可以根据path打印出<i,j>的路径