佛洛依德算法的学习与实现

1、问题引入

　　带权有向图中单源点的最短路径问题可以用地杰斯特拉算法求解，如果要求解图中每一对顶点之间的最短路径，类似可以想到的方法为：每次以一个顶点为源点，重复执行地杰斯特拉算法算法n次，这样，便可以求得每一对顶点之间的最短路径，总的执行时间为O(n³）。

　　这里可以采用另外一种求解算法：Floyd算法。

2、Floyd的基本思想为：

　　从邻接矩阵a开始进行n次迭代，第一次迭代后a[i,j]的值是从vi到vj且中间不经过变化大于1的顶点的最短路径长度；第k次迭代后a[i,j]的值是从vi到vj且中间不经过变化大于k的顶点的最短路径长度 第n次迭代后a[i,j]的值就是从vi到vj的最短路径长度。

3、算法描述：

　　(1) 用数组d[i][j]来记录i,j之间的最短距离。初始化d[i][j],若i=j则d[i][j]=0,
　　　　若i,j之间有边连接则d[i][j]的值为该边的权值，否则d[i][j]的值为max 。
　　(2) 对所有的k值从1到n，修正任意两点之间的最短距离，计算d[i][k]+d[k][j]的值，
　　　　若小于d[i][j],则d[i][j]= d[i][k]+d[k][j]，否则d[i][j]的值不变。

4、具体实现：

　　带权有向图如下：

在2.txt文件中保存的带权有向图的数据为：

其中第一个数据4表述图中有4个节点，其他的四行四列数据表示各个节点之间的路径长度，9999表示两个节点之间不可达。

具体代码为：

#include<stdio.h>
#include<stdlib.h>
#define max 9999
void Floyd(int,int **,int**,int**);
void Searchpath(int,int,int**,int**);
void main()
{
    int i,j,num,first,last;
    FILE *p;
    p=fopen("2.txt","r");
    if(p==NULL)
    {
        printf("无法打开2.txt");
        exit(-1);
    }
    fscanf(p,"%d",&num);//获取点的个数；
    int **a=(int**)malloc(sizeof(int*)*num);
    for(i=0;i<num;i++)
        a[i]=(int*)malloc(sizeof(int)*num);
    for(i=0;i<num;i++)//获取图中各个点之间的路径长度；
        for(j=0;j<num;j++)
            fscanf(p,"%d",&a[i][j]);
    //path[i][j]用于记录从i到j的最短路径上j点的前一个节点
    int **path=(int**)malloc(sizeof(int*)*num);
    for(i=0;i<num;i++)
        path[i]=(int*)malloc(sizeof(int)*num);
    //d[i][j]用于记录从i到j的最短路径的长度
    int **d=(int**)malloc(sizeof(int*)*num);
    for(i=0;i<num;i++)
        d[i]=(int*)malloc(sizeof(int)*num);
    //佛洛依德算法程序调用
    Floyd(num,path,d,a);
    printf("最终得到的距离矩阵为：\n");
    for(i=0;i<num;i++)
    {
        for(j=0;j<num;j++)
            printf("%d  ",d[i][j]);
        printf("\n");
    }
    printf("请输入起始点(小于%d)：",num);
    scanf("%d",&first);
    printf("\n请输入终止点(小于%d)：",num);
    scanf("%d",&last);
    printf("起始点%d到终止点%d的最短路径长度为：%d\n",first,last,d[first][last]);
    Searchpath(first,last,path,d);//利用path[i][j]得出从i到j的最短路径
}
void Floyd(int num,int **path,int**d,int **a)
{
    int i,j,k;
    for(i=0;i<num;i++)
    {
        for(j=0;j<num;j++)//初始化
        {
            if(a[i][j]<max) path[i][j]=j;//从i到j有路径
            else path[i][j]=-1;
            d[i][j]=a[i][j];
        }
    }
    for(k=0;k<num;k++)
        for(i=0;i<num;i++)
            for(j=0;j<num;j++)
                if(d[i][j]>d[i][k]+d[k][j])//从i到j的一条更短的路径
                {
                    d[i][j]=d[i][k]+d[k][j];
                    path[i][j]=path[i][k];
                }
}
void Searchpath(int first,int last,int **path,int**d)
{
    int k;
    if(d[first][last]==max)
        printf("起始点%d到终止点%d不可达",first,last);
    else
    {
        printf("起始点到终点的路径为：");
        k=last;
        printf("%d <--　",k);
        while((k!=first)&&(k!=path[first][k]))
        {
            k=path[first][k];
            printf("%d <-- ",k);
            if(k==path[first][k])
                k=first;
        }
        printf("%d\n",first);
    }
}

5、参考资料：

　　（1）严蔚敏，数据结构。

　　（2）http://blog.sina.com.cn/s/blog_3fe961ae0100nl6g.html

　　（3）http://zhidao.baidu.com/question/349458736.html