Floyd算法

　　Dijkstra算法是解决单源最短路径的问题，就是某个点到其余各个点的最短路径，Floyd算法是解决任意两点间最短路径问题的。

　　算法的大致流程如下：

　　设置两个二维矩阵A和path，A记录任意两个顶点最短路径长度，path记录当前两顶点最短路径上要经过的中间节点。

　　n个顶点，从0到n-1，每次以i为中间节点进行检测，检测所有顶点对(j,k)，如果A[j][k]>A[j][i]+A[i][j]，则令A[j][k]=A[j][i]+A[i][j]，令path[j][k]=i。

　　依次检测完所有0~n-1的顶点，算法结束。最终的结果存储在A和path矩阵中。

#include<cstdio>
#define MAXSIZE 100
#define INF 99999
int A[MAXSIZE][MAXSIZE];
int G[MAXSIZE][MAXSIZE];
int path[MAXSIZE][MAXSIZE];
void init(int n)
{
    for(int i=0; i<n; ++i)
    {
        for(int j=0; j<n; ++j)
        {
            path[i][j]=-1;
            if(i==j)
                G[i][j]=A[i][j]=0;
            else
                G[i][j]=A[i][j]=INF;
        }
    }
}
void create(int e)
{
    int a,b,val;
    for(int i=0; i<e; ++i)
    {
        scanf("%d%d%d",&a,&b,&val);
        A[a][b]=val;
        G[a][b]=val;
    }
    for(int i=0; i<4; ++i)
    {
        for(int j=0; j<4; ++j)
        {
            printf("%d	",G[i][j]);
        }
        printf("
");
    }
    printf("*******************************
");
}
void Floyd(int n)
{
    for(int i=0; i<n; ++i)
    {
        for(int j=0; j<n; ++j)
        {
            for(int k=0; k<n; ++k)
            {
                if(j==k)
                    continue;
                if(A[j][k]>A[j][i]+A[i][k])
                {
                    A[j][k]=A[j][i]+A[i][k];
                    path[j][k]=i;
                }
            }
        }
    }
}
void print(int n)
{
    for(int i=0; i<n; ++i)
    {
        for(int j=0; j<n; ++j)
        {
            printf("%d	",A[i][j]);
        }
        printf("
");
    }
    printf("*******************************
");
    for(int i=0; i<n; ++i)
    {
        for(int j=0; j<n; ++j)
        {
            printf("%d	",path[i][j]);
        }
        printf("
");
    }
}
void printPath(int u,int v)
{
    if(path[u][v]==-1)
        printf("%d->",u);
    else
    {
        int mid = path[u][v];
        printPath(u,mid);
        printPath(mid,v);
    }
}
int main()
{
    int n,e;
    scanf("%d%d",&n,&e);
    init(n);
    create(e);
    Floyd(n);
    print(n);
    int u,v;
    scanf("%d%d",&u,&v);
    printPath(u,v);
    printf("%d",v);
    return 0;
}

　　算法的时间复杂度为O（n³）。

      

　　例如，我们以上图所示的图进行计算，第一部分为图的邻接矩阵，第二部分为求得的A，第三部分为求得的path。

　　我们要求1到0的最短路径。

1. path[1][0]=3，所以从1到0最短路要经过3，以3为起点
2. path[3][0]=2，所以从3到1最短路要经过2，以2为起点
3. path[2][0]=-1，所以，从顶点2有直接到0的边，结束

所以求最短路要用到递归，分别处理前后两段路径。