算法分析与设计实践 - 作业2 - Floyd算法与Dijkstra算法

1 .问题

1.1

用Floyd算法求解下图各个顶点的最短距离。写出Floyd算法的伪代码和给出距离矩阵（顶点之间的最短距离矩阵）。

1.2

对于下图使用Dijkstra算法求由顶点a到顶点h的最短路径。

2.解析

2.1

Floyd算法又称为弗洛伊德算法或插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法,算法目标是寻找数组D[N][N]种，从顶点i到顶点j的最短路径D[i][j]，对于每一对顶点i和j,看是否存在顶点k使得通过k中转得到的D[i][j]更小。
算法过程： 
１、用D[v][w]记录每一对顶点的最短距离。 
２、依次扫描每一个点，并以其为基点再遍历所有每一对顶点D[][]的值，看看是否可用过该基点让这对顶点间的距离更小。

初始化矩阵：

距离矩阵：

2.2

迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。
邻接矩阵：

3.算法

//Floyd算法
#include <stdio.h>
      int main()  
      {  
      int e[10][10],k,i,j,n,m,t1,t2,t3;  
      int inf=9999; //用inf(infinity的缩写)存储一个我们认为的正无穷值
      //读入n和m，n表示顶点个数，m表示边的条数
          scanf("%d %d",&n,&m);  
      //初始化
      for(i=1;i<=n;i++)  
     for(j=1;j<=n;j++)  
     if(i==j) e[i][j]=0;    
     else e[i][j]=inf;  
     //读入边
     for(i=1;i<=m;i++)  
         {  
             scanf("%d %d %d",&t1,&t2,&t3);  
             e[t1][t2]=t3;  
         }  
    //Floyd算法核心语句
     for(k=1;k<=n;k++)  
          for(i=1;i<=n;i++)  
     for(j=1;j<=n;j++)  
     if(e[i][j]>e[i][k]+e[k][j] )   
                         e[i][j]=e[i][k]+e[k][j];  
     //输出最终的结果
     for(i=1;i<=n;i++)  
         {  
     for(j=1;j<=n;j++)  
             {  
                 printf("%10d",e[i][j]);  
             }  
             printf("\n");  
         }  
     return 0;  
     }  

//Dijkstra算法
#include <stdio.h>  
    int main(){  
        int e[10][10],dis[10],book[10],i,j,n,m,t1,t2,t3,u,v,min;  
        int inf=99999999; //用inf(infinity的缩写)存储一个我们认为的正无穷值  
        //读入n和m，n表示顶点个数，m表示边的条数  
        scanf("%d %d",&n,&m);  
        //初始化  
        for(i=1;i<=n;i++)  
            for(j=1;j<=n;j++)  
                if(i==j) e[i][j]=0;    
                  else e[i][j]=inf;  
        //读入边  
        for(i=1;i<=m;i++){  
            scanf("%d %d %d",&t1,&t2,&t3);  
            e[t1][t2]=t3;  
        }  
        //初始化dis数组，这里是1号顶点到其余各个顶点的初始路程  
        for(i=1;i<=n;i++)  
            dis[i]=e[1][i];  
        //book数组初始化  
        for(i=1;i<=n;i++)  
            book[i]=0;  
        book[1]=1;  
        //Dijkstra算法核心语句  
        for(i=1;i<=n-1;i++)  {  
            //找到离1号顶点最近的顶点  
            min=inf;  
            for(j=1;j<=n;j++)  {  
                if(book[j]==0 && dis[j]<min)  {  
                    min=dis[j];  
                    u=j;  
                }  
            }  
            book[u]=1;  
            for(v=1;v<=n;v++)  {  
                if(e[u][v]<inf)  
                {  
                    if(dis[v]>dis[u]+e[u][v])   
                        dis[v]=dis[u]+e[u][v];  
                }  
            }      
        }  
        //输出最终的结果  
        for(i=1;i<=n;i++)  
            printf("%d ",dis[i]);  
        getchar();  
        getchar();  
        return 0;  
    }

4.分析

记顶点数V，边数E
Floyd算法
时间复杂度为O(N2)
Dijkstra算法：
时间复杂度是O(N2N)，即O(N2)

5.码源

源码地址： https://github.com/chaoxing0910/ex2