floyd算法

   

在图论中经常会遇到这样的问题，在一个有向图里，求出任意两个节点之间的最短距离。我们在离散数学、数据结构课上都遇到过这个问题，在计算机网络里介绍网络层的时候好像也遇到过这个问题，记不请了… 但是书本上一律采取的是Dijkstra算法，通过Dijkstra算法可以求出单源最短路径，然后逐个节点利用Dijkstra算法就可以了。不过在这里想换换口味，采取Robert Floyd提出的算法来解决这个问题。下面让我们先把问题稍微的形式化一下：

      如果有一个矩阵D=[d(ij)]，其中d(ij)>0表示i城市到j城市的距离。若i与j之间无路可通，那么d(ij)就是无穷大。又有d(ii)=0。编写一个程序，通过这个距离矩阵D，把任意两个城市之间的最短与其行径的路径找出来。
     我们可以将问题分解，先找出最短的距离，然后在考虑如何找出对应的行进路线。如何找出最短路径呢，这里还是用到动态规划的知识，对于任何一个城市而言，i到j的最短距离不外乎存在经过i与j之间的k和不经过k两种可能，所以可以令k=1，2，3，…，n(n是城市的数目)，在检查d(ij)与d(ik)+d(kj)的值；在此d(ik)与d(kj)分别是目前为止所知道的i到k与k到j的最短距离，因此d(ik)+d(kj)就是i到j经过k的最短距离。所以，若有d(ij)>d(ik)+d(kj)，就表示从i出发经过k再到j的距离要比原来的i到j距离短，自然把i到j的d(ij)重写为d(ik)+d(kj)，每当一个k查完了，d(ij)就是目前的i到j的最短距离。重复这一过程，最后当查完所有的k时，d(ij)里面存放的就是i到j之间的最短距离了。所以我们就可以用三个for循环把问题搞定了，但是有一个问题需要注意，那就是for循环的嵌套的顺序：我们可能随手就会写出这样的程序，但是仔细考虑的话，会发现是有问题的。

                     for(int i=0; i<n; i++)
                           for(int j=0; j<n; j++)
                                for(int k=0; k<n; k++)  
    

     问题出在我们太早的把i-k-j的距离确定下来了，假设一旦找到了i-p-j最短的距离后，i到j就相当处理完了，以后不会在改变了，一旦以后有使i到j的更短的距离时也不能再去更新了，所以结果一定是不对的。所以应当象下面一样来写程序：

                    for(int k=0; k<n; k++)
                         for(int i=0; i<n; i++)
                              for(int j=0; j<n; j++)

if(d[i][j]>d[i][k] + d[k][j] )    d[i][j] = d[i][k] + d[k][j]  ;   

                                           这里   d[i][k]    d[k][j]后面都会动态更新的    ，所以   d[i][j]  后面也会变化 ，不是一次就能确定的

因此floyd的最外层循环：
for (k = 0; k < n; k++) ...
就是分别求出 A0(i,j), A1(i,j), ..., An(i,j) 

先求出所有 A0(i,j)，然后再出所有A1(i,j)， ..., 最后求出所有的An(i,j)    （所以内层有两个循环）

    这样作的意义在于固定了k，把所有i到j而经过k的距离找出来，然后象开头所提到的那样进行比较和重写，因为k是在最外层的，所以会把所有的i到j都处理完后，才会移动到下一个k，这样就不会有问题了，看来多层循环的时候，我们一定要当心，否则很容易就弄错了。
     接下来就要看一看如何找出最短路径所行经的城市了，这里要用到另一个矩阵P，它的定义是这样的：p(ij)的值如果为p，就表示i到j的最短行经为i->…->p->j，也就是说p是i到j的最短行径中的j之前的最后一个城市。P矩阵的初值为p(ij)=i。有了这个矩阵之后，要找最短路径就轻而易举了。对于i到j而言找出p(ij)，令为p，就知道了路径i->…->p->j；再去找p(ip)，如果值为q，i到p的最短路径为i->…->q->p；再去找p(iq)，如果值为r，i到q的最短路径为i->…->r->q；所以一再反复，到了某个p(it)的值为i时，就表示i到t的最短路径为i->t，就会的到答案了，i到j的最短行径为i->t->…->q->p->j。因为上述的算法是从终点到起点的顺序找出来的，所以输出的时候要把它倒过来。
     但是，如何动态的回填P矩阵的值呢？回想一下，当d(ij)>d(ik)+d(kj)时，就要让i到j的最短路径改为走i->…->k->…->j这一条路，但是d(kj)的值是已知的，换句话说，就是k->…->j这条路是已知的，所以k->…->j这条路上j的上一个城市(即p(kj))也是已知的，当然，因为要改走i->…->k->…->j这一条路，j的上一个城市正好是p(kj)。所以一旦发现d(ij)>d(ik)+d(kj)，就把p(kj)存入p(ij)。

 floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所在），floyd算法加入了这个概念

    A^k(i,j)：表示从i到j中途不经过索引比k大的点的最短路径。

    这个限制的重要之处在于，它将最短路径的概念做了限制，使得该限制有机会满足迭代关系，这个迭代关系就在于研究：假设A^k(i,j)已知，是否可以借此推导出A^k-1(i,j)。

    假设我现在要得到A^k(i,j)，而此时A^k(i,j)已知，那么我可以分两种情况来看待问题：1. A^k(i,j)沿途经过点k；2. A^k(i,j)不经过点k。如果经过点k，那么很显然，A^k(i,j) = A^k-1(i,k) + A^k-1(k,j)，为什么是A^k-1呢？因为对(i,k)和(k,j)，由于k本身就是源点（或者说终点），加上我们求的是A^k(i,j)，所以满足不经过比k大的点的条件限制，且已经不会经过点k，故得出了A^k-1这个值。那么遇到第二种情况，A^k(i,j)不经过点k时，由于没有经过点k，所以根据概念，可以得出A^k(i,j)=A^k-1(i,j)。现在，我们确信有且只有这两种情况---不是经过点k，就是不经过点k，没有第三种情况了，条件很完整，那么是选择哪一个呢？很简单，求的是最短路径，当然是哪个最短，求取哪个，故得出式子：

    A^k(i,j) = min( A^k-1(i,j), A^k-1(i,k) + A^k-1(k,j) )

因此floyd的最外层循环：
for (k = 0; k < n; k++) ...
就是分别求出  A0(i,j),  A1(i,j), ...,  An(i,j) 
我屡次写错floyd的程序，今天又写错一次。。尽管它很短，但原理真的很牛比。

只要知道了原理，就不会再写错了！

为了加深对floyd算法的认识，特地搜了一下floyd算法的证明。原来floyd算法的本质是一个动态规划的过程。

状态转移方程：

f[k][i][j]=min(f[k-1][i][j],f[k-1][i][k]+f[k-1][k][j])

f[k][i][j]表示只经过前k个点(包括k)，从i到j的最小值。当k从1到n时，就是从i到j的最小值。我们熟悉的用二维数组的写法实际上是对空间的一种压缩。

解释一下：

计算只经过前k个点，从i到j的最小值时，有两种情况需要考虑：经过第k个点和不经过第k个点。经过第k个点则距离应是从i到k的最小值和从k到j的最小值，两个最小值的路径都必须只经过前k-1个点（为什么是k-1而不是k，事实上他们两数值相同，因为起点和终点已经有第k个点，只是在dp的过程中先产生k-1，f[k][i][k]和f[k][k][j]有可能比f[k][i][j]的值晚计算出，就不能在计算f[k][i][j]时用到这两个值）。不经过k的点则距离与只经过前k-1个点时一样。