最短路问题（floyd算法）（优化待续）

问题描述：

最短路问题（short-path problem）：若网络中的每条边都有一个数值（长度、成本、时间等），则找出两节点（通常是源节点和阱节点）之间总权和最小的路径就是最短路问题。最短路问题是网络理论解决的典型问题之一，可用来解决管路铺设、线路安装、厂区布局和设备更新等实际问题。

1.floyd算法

算法描述：

Floyd算法又称为插点法，是一种用于寻找给定的加权图中多源点之间最短路径的算法。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。

时间复杂度：O（n^3）  空间复杂度：O（n^2）

可以看下这篇文章，讲得非常清楚：http://blog.chinaunix.net/uid-26548237-id-3834873.html

下面就讲下我对这个算法的理解：

首先这个算法能做的事，就是寻找给定的加权图中多源点之间最短路径

也就是这张图：

这里有N个点，互相之间的路径长度不一，怎么求其中任意两点的最短路径。

floyd算法的思路就是从比较入手，比较两点直接连通和隔一个点连通的长度。

从v0开始，遍历任意两个点，寻找有没有两个点通过v0的最短路径比这两点直接连通的要短。

比如v0和v2，要比较这两个点直接连通和隔一个点连通的长度。从图上可知，v0-v2的最短路径是经过v1,走0-1-2，而不是直接0-2。所以结果是经过v1比直接连通要短。

再比如v0和v4，要比较这两个点直接连通和隔一个点连通的长度，但v0和v4没有直接连通怎么办，就设v0-v4直接连通的长度是无穷大，这样不管是经过v1还是经过v2，都比直接连通的长度要短。

找到后怎么办，就把最短的长度和路径结果保存起来，以此再遍历下一个点v1，继续比较。

全部遍历一遍后，就可以得到任意两点之间的最短路径了。

具体实现如下：

 #include <iostream>
 using namespace std;

 #define MAXVEX 20
 #define MAXEDGE 20
 #define INFINITY 65535

 typedef struct
 {
           int vexs[MAXVEX];
           int arc[MAXVEX][MAXVEX];
           int numVertexes,numEdges;
 }MGraph;

 typedef int Patharc[MAXVEX][MAXVEX];
 typedef int ShortPathTable[MAXVEX][MAXVEX];

 void CreateGraph(MGraph* G)
 {
           cout<<"请输入边数和顶点数:\n";
           int d,n,i,j;
           cin>>d>>n;
           G->numVertexes = n;
           G->numEdges = d;

           //给顶点和边初始化
           for(i = ;i<G->numVertexes;i++)
                     G->vexs[i] = i;
           for(i = ;i<G->numVertexes;i++)
           {
                     for(j = ;j<G->numVertexes;j++)
                     {
                               if(i==j)
                                         G->arc[i][j] = ;
                               else
                                         G->arc[i][j] = G->arc[j][i] = INFINITY;
                     }
           }

           G->arc[][]=;
           G->arc[][]=;
           G->arc[][]=;
           G->arc[][]=;
           G->arc[][]=;

           G->arc[][]=;
           G->arc[][]=;
           G->arc[][]=;
           G->arc[][]=;
           G->arc[][]=;

           G->arc[][]=;
           G->arc[][]=;
           G->arc[][]=;
           G->arc[][]=;
           G->arc[][]=;

           G->arc[][]=;

           for(i = ;i<G->numVertexes;i++)
           {
                     for(j = i;j<G->numVertexes;j++)
                     {
                               G->arc[j][i] = G->arc[i][j];
                     }
           }
 }

 /* Floyd算法，求网图G中各顶点v到其余顶点w的最短路径P[v][w]及带权长度D[v][w]。 */
 void ShortestPath_Floyd(MGraph G, Patharc *P, ShortPathTable *D)
 {
           int v,w,k;
           for(v = ;v<G.numVertexes;v++)
           {
                     for(w = ;w<G.numVertexes;w++)
                     {
                               (*P)[v][w] = w;
                                /* 初始化P */
                               (*D)[v][w] = G.arc[v][w];
                               /* D[v][w]值即为对应点间的权值 */
                     }

           }
           for(k = ;k<G.numVertexes;k++)
           {
                     for(v = ;v<G.numVertexes;v++)
                     {
                               for(w = ;w<G.numVertexes;w++)
                               {
                                         if((*D)[v][w]>(*D)[v][k]+(*D)[k][w])
                                         {
                                                   (*D)[v][w] = (*D)[v][k]+(*D)[k][w];
                                                   (*P)[v][w] = (*P)[v][k];
                                         }

                               }

                     }
           }

 }

 int main()
 {
     int v,w,k=-;

     MGraph G;

     Patharc P;
     ShortPathTable D;

     CreateGraph(&G);

     ShortestPath_Floyd(G,&P,&D);

     cout<<"各区间最短路径如下：\n";
     for(v = ;v<G.numVertexes;v++)
     {
               for(w = v+;w<G.numVertexes;w++)
               {
                         cout<<"v"<<v<<"-v"<<w<<" weight: "<<D[v][w];
                         k = P[v][w];
                         cout<<" path: "<<v;
                         while(k!=w)
                         {
                                   cout<<" -> "<<k;
                                   k = P[k][w];
                               }
                               cout<<" -> "<<w<<" "<<endl;
                     }
                     cout<<endl;

           }

           cout<<"最短路径D\n";

           for(v=; v<G.numVertexes; ++v)
           {
                     for(w=; w<G.numVertexes; ++w)
                     {
                               cout<<D[v][w]<<"  ";
                     }
                     cout<<endl;
           }

           cout<<"最短路径P\n";

           for(v=; v<G.numVertexes; ++v)
           {
                     for(w=; w<G.numVertexes; ++w)
                     {
                               cout<<P[v][w]<<"  ";
                     }
                     cout<<endl;
           }

           return ;

 }

算法优化：

floyd(权值非负)适用于有向图和无向图

1 floyd 的思想就是通过枚举n个点利用DP的思想来更新最短距离的，假设当前枚举到第k个点，那么就有任意的两个点i , j ，如果i k 相连 j k 相连 那么就可以知道这个时候dis[i][j] = min(dis[i][j] , dis[i][k] + dis[k][j]);，那么只要枚举完n个点，那么就说明已经完全更新完所有两点直间的最短路。

2 floyd算法是最简单的最短路径的算法，可以计算图中任意两点间的最短路径。floyd算法的时间复杂度为o(n^3)，如果是一个没有边权的图，把相连的两点间的距离设为dis[i][j]=1.不相连的两点设为无穷大，用floyd算法可以判断i j两点是否相连。
3 floyd 算法不允许所有的权值为负的回路。可以求出任意两点之间的最短距离。处理的是无向图
4 缺点是时间复杂度比较高，不适合计算大量数据

5 如果dis[i][i] != 0，说明此时存在环。

6 如果利用floyd求最小值的时候，初始化dis为INF ， 如果是求最大值的话初始化为-1.