最短路径算法（floyd算法）

最新推荐文章于 2021-01-21 19:13:20 发布

zhusongshuai

最新推荐文章于 2021-01-21 19:13:20 发布

阅读量409

点赞数

分类专栏：数据结构和算法

本文链接：https://blog.csdn.net/zhusongshuai/article/details/41074541

版权

数据结构和算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Floyd算法是求解最短路径的动态规划算法。 Floyd算法可以说是Warshall算法的扩展，三个for循环就可以解决问题，所以它的时间复杂度为O(n^3)。

Floyd算法的基本思想如下：从任意节点A到任意节点B的最短路径不外乎2种可能，1是直接从A到B，2是从A经过若干个节点X到B。所以，我们假设Dis(AB)为节点A到节点B的最短路径的距离，对于每一个节点X，我们检查Dis(AX) + Dis(XB) < Dis(AB)是否成立，如果成立，证明从A到X再到B的路径比A直接到B的路径短，我们便设置Dis(AB) = Dis(AX) + Dis(XB)，这样一来，当我们遍历完所有节点X，Dis(AB)中记录的便是A到B的最短路径的距离。很简单吧，代码看起来可能像下面这样：

for ( int i = 0; i < 节点个数; ++i )
{
    for ( int j = 0; j < 节点个数; ++j )
    {
        for ( int k = 0; k < 节点个数; ++k )
        {
            if ( Dis[i][k] + Dis[k][j] < Dis[i][j] )
            {
                // 找到更短路径
                Dis[i][j] = Dis[i][k] + Dis[k][j];
            }
        }
    }
}

但是这里我们要注意循环的嵌套顺序，如果把检查所有节点X放在最内层，那么结果将是不正确的，为什么呢？因为这样便过早的把i到j的最短路径确定下来了，而当后面存在更短的路径时，已经不再会更新了。让我们来看一个例子，看下图：

但是这里我们要注意循环的嵌套顺序，如果把检查所有节点X放在最内层，那么结果将是不正确的，为什么呢？因为这样便过早的把i到j的最短路径确定下来了，而当后面存在更短的路径时，已经不再会更新了。

让我们来看一个例子，看下图：

图中红色的数字代表边的权重。如果我们在最内层检查所有节点X，那么对于A->B，我们只能发现一条路径，就是A->B，路径距离为9。而这显然是不正确的，真实的最短路径是A->D->C->B，路径距离为6。造成错误的原因就是我们把检查所有节点X放在最内层，造成过早的把A到B的最短路径确定下来了，当确定A->B的最短路径时Dis(AC)尚未被计算。所以，我们需要改写循环顺序，如下：

for ( int k = 0; k < 节点个数; ++k )
{
    for ( int i = 0; i < 节点个数; ++i )
    {
        for ( int j = 0; j < 节点个数; ++j )
        {
            if ( Dis[i][k] + Dis[k][j] < Dis[i][j] )
            {
                // 找到更短路径
                Dis[i][j] = Dis[i][k] + Dis[k][j];
            }
        }
    }
}

这样一来，对于每一个节点X，我们都会把所有的i到j处理完毕后才继续检查下一个节点。

那么接下来的问题就是，我们如何找出最短路径呢？这里需要借助一个辅助数组Path，它是这样使用的：Path(AB)的值如果为P，则表示A节点到B节点的最短路径是A->...->P->B。这样一来，假设我们要找A->B的最短路径，那么就依次查找，假设Path(AB)的值为P，那么接着查找Path(AP)，假设Path(AP)的值为L，那么接着查找Path(AL)，假设Path(AL)的值为A，则查找结束，最短路径为A->L->P->B。

那么，如何填充Path的值呢？很简单，当我们发现Dis(AX) + Dis(XB) < Dis(AB)成立时，就要把最短路径改为A->...->X->...->B，而此时，Path(XB)的值是已知的，所以，Path(AB) = Path(XB)。

package algorithm;

import java.util.ArrayList;
//
public class Floyd {
 
        public static int M = Integer.MAX_VALUE;     
        public static int MAXSUM(int a,int b){      
            return (a!=M&&b!=M)?(a+b):M;     
        }
        public static ArrayList<Integer[][]> flody(Integer[][] dist){
             Integer[][] path=new Integer[6][6];//存储的是从i->j经过的最后一个节点     
               for (int i = 0; i < 6; i++) {     
                for (int j = 0; j < 6; j++) {
                    path[i][j]=i;
                    }
            }
            for(int k=0;k<6;k++){
                for (int i = 0; i < 6; i++) {
                    for (int j = 0; j < 6; j++) {
                        if(dist[i][j]>MAXSUM(dist[i][k], dist[k][j])){   
                            path[i][j]=path[k][j];//存储的是从i->j经过的最后一个节点        
                            dist[i][j]=MAXSUM(dist[i][k], dist[k][j]);    
                        }
                    }
                }
            }                    
            ArrayList<Integer[][]> list =new ArrayList<Integer[][]>();          
            list.add(dist);
            list.add(path);         
            return list;     
        }
        public static Integer[] reverse(Integer[] chain,int count){
            int temp;
           for(int i=0,j=count-1;i<j;i++,j--){
               temp=chain[i];
               chain[i]=chain[j];
               chain[j]=temp;
           }
           return chain;     
        }
        public static void display_path(ArrayList<Integer[][]> list){
            Integer[][] dist=list.get(0);      
            Integer[][] path=list.get(1);      
            Integer[] chain=new Integer[6];
           System.out.println("orign->dist"+" dist "+" path");
            for (int i = 0; i <6; i++) {
                for (int j = 0; j < 6; j++) {
                    if(i!=j){//只是避免了vi->vi的输出
                        //输出源到目的地
                       System.out.print("\n   "+(i)+"->"+(j)+"     ");      
                        //输出最短路径的长度      
                        if(dist[i][j]==M){       
                            System.out.print(" NA ");
                       }else{
                              System.out.print(dist[i][j]+"      ");       
                            int count=0;       
                            int k=j;       
                            do {        
                                k=chain[count++]=path[i][k];       
                            } while (i!=k);
                              chain=reverse(chain,count);        
                              //输出路径
                              System.out.print(chain[0]+"");  
                            for(k=1;k<count;k++){
                                System.out.print("->"+(chain[k]));
                              }
                              System.out.print("->"+j);
                       }
                    }
                 }
            }
        }
       public static void main(String[] args) {   
            Integer[][] dist = {     
                    { 0, 1, 4, M, M, M },     
                    { 1, 0, 2, 7, 5, M },     
                    { 4, 2, 0, M, 1, M },     
                    { M, 7, M, 0, 3, 2 },     
                    { M, 5, 1, 3, 0, 6 },  
                    { M, M, M, 2, 6, 0 } };// 建立一个权值矩阵
    
            ArrayList<Integer[][]>  list=flody(dist);
            display_path(list);                   
        }
    }

感谢：http://www.cnblogs.com/twjcnblog/archive/2011/09/07/2170306.html