【最短路径Floyd算法详解推导过程】看完这篇，你还能不懂Floyd算法？还不会？

简介

 Floyd-Warshall算法（Floyd-Warshall algorithm），是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与Dijkstra算法类似。该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。

简单的说就是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权的最短路径问题，同时也被用于计算有向图的传递闭包。Floyd-Warshall算法的时间复杂度为O(N3)，空间复杂度为O(N2)。

解决最短路径问题有几个出名的算法:

1.dijkstra算法,最经典的单源最短路径算法
2.bellman-ford算法,允许负权边的单源最短路径算法
3.spfa,其实是bellman-ford+队列优化,其实和bfs的关系更密一点
4.floyd算法,经典的多源最短路径算法

今天先说说Floyd

Floyd算法详解

描述

a）如图：存在【0,1,2,3】 4个点，两点之间的距离就是边上的数字，如果两点之间，没有边相连，则无法到达，为无穷大。
b）要让任意两点（例如从顶点a点到顶点b）之间的路程变短，只能引入第三个点（顶点k），并通过这个顶点k中转即a->k->b，才可能缩短原来从顶点a点到顶点b的路程。那么这个中转的顶点k是0~n中的哪个点呢？

image.png

算法过程

准备

1）如图 0->1距离为5，0->2不可达，距离为∞，0->3距离为7……依次可将图转化为邻接矩阵（主对角线，也就是自身到自身，我们规定距离为0，不可达为无穷大），如图矩阵用于存放任意一对顶点之间的最短路径权值。

image.png

2）再创建一个二维数组Path路径数组，用于存放任意一对顶点之间的最短路径。每个单元格的内容表示从i点到j点途经的顶点。（初始还未开始查找，默认-1）

image.png

开始查找

1）列举所有的路径（自己到自己不算）

image.png

即为：
0 -> 1 , 0 -> 2 , 0 -> 3 ,
1 -> 0 , 1 -> 2 , 1 -> 3 ,
2 -> 0 , 1 -> 1 , 1 -> 3
转化成二元数组即为：
{0，1}，{0，2}，{0，3}，{1，0}，{1，2}，{1，3}，{2，0}，{2，1}，{2，3}，{3，0}，{3，1}，{3，2}

2）选择编号为0的点为中间点

{0，1}，{0，2}，{0，3}，{1，0}，{1，2}，{1，3}，{2，0}，{2，1}，{2，3}，{3，0}，{3，1}，{3，2}
从上面中二元组集合的第一个元素开始，循环执行以下过程：

1. 用i，j两个变量分别指向二元组里的两个元素，比如{0，1}这个二元组，i指向0；j指向1
2. 判断 (A[ i ][ 0 ]+A[ 0 ][ j ] ) < A[ i ][ j ] （即判断 i -> j，i点到j点的距离是否小于从0点中转的距离），如果false，则判断下一组二元数组。
3. 如果表达式为真，更新A[ i ] [ j ]的值为A[ i ] [ 0 ] + A[ 0 ] [ j ]，Path[ i ] [ j ]的值为点0（即设置i到j要经过0点中转）

{0，1}按照此过程执行之后，

image.png

0->0 + 0->1的距离不小于0->1 ，下一组{0，2}，{0，3}， {1，0}，{2，0}，{3，0}也同理。

{1，2}按照此过程执行，A[1,0] 无穷大， A[0,2]也是无穷大，而A[1,4] = 4，则1点到2点肯定不会从0点中转。

A[1][0]无穷大同理下一组{1，2}， {1，3}也同理。

{2，1}按照此过程执行，A[2][0] = 3 ,A[0][1]=5 ，A[2][1] = 3那么 A[2][0]+ ,A[0][1] > A[2][1]
…………
依次类推，遍历二元组集合，没有0点适合做中转的

3）选择编号为1的点为中间点

4）选择编号为2的点为中间点

依次类推，遍历二元组集合{0，1}，{0，2}，{0，3}，{1，0}，{1，2}，{1，3}，{2，0}，{2，1}，{2，3}，{3，0}，{3，1}，{3，2}
，当遍历{3，0}时，A[3][2] = 1 ,A[2][0]=3 ，A[3][0] = 不可达，那么 2点适合做从3点到0点之间的中转点。
设置距离矩阵A[3][0] = 1+3 =4 ，Path矩阵Path[3][0] = 2点，表示从3到0在2点中转，距离最近。

image.png

如图表示（红色单元格），从3到0，最近距离为4，在2点中转。

依次类推，遍历完二元组集合

image.png

5）选择编号为3的点为中间点，最终结果

依次类推，遍历二元组集合，直到所有的顶点都做过一次中间点为止。

image.png

6）根据最终结果，就可以知道任意2点的最短距离和路径

比如1点到2点怎么走？根据路径Path矩阵,Path[1][2] = 3，表示从点3中转，即 1-> 3 ->2

image.png

6）如果中转点不止1个呢？

有时候不只通过一个点，而是经过两个点或者更多点中转会更短，即a->k1->k2b->或者a->k1->k2…->k->i…->b。
比如顶点1到顶点0，我们看数组Path
Path[1][0] = 3，说明顶点3是中转点，那么再从3到0
Path[3][0] = 2，说明从3到0，顶点2是中转点，然后在从2到0
Path[2][0] = -1，说明顶点2到顶点0没有途径顶点，也就是说，可以由顶点2直接到顶点0，即它们有边连接。

最终，最短路径为1->3->2->0，距离为 A[1][0] = 6 。
显然，这是一个逐层递进，递归的过程。

算法实现

基本定义

    //    表示无穷大 即不可达
    public static int MAX = Integer.MAX_VALUE;
    //    距离矩阵
    public int[][] dist;
    //    路径Path矩阵
    public int[][] path;

核心算法

//        核心算法
       for(int k = 0 ; k < size ; k++){
           for(int i = 0;i < size;i++){
               for(int j = 0 ;j < size;j++){
//                判断如果 ik距离可达且 kj距离可达 且 i和j的距离是否大于 i-> k 与 k->j的距离和
                    if( dist[i][k] != MAX &&  dist[k][j] != MAX  &&  dist[i][j] > (dist[i][k] + dist[k][j]) ){
                        path[i][j]= k;
                        dist[i][j]= dist[i][k] + dist[k][j];
                    }
               }
           }
       }

运行结果

image.png

源码下载

Floyd算法java实现-下载

Floyd算法java实现

看完这篇文章如果你还不会Floyd，请留言评论。

image.png