点与点的最短路径Floyd-warshall算法

最短路径的结构
Floyd 算法考虑的是一条路径上的中间结点。对于任意结点对 i，j∈V，考虑从结点 i 到结点 j 的所有中间结点均取自集合 {1, 2, …, k} 的路径（该集合是 V 的一个子集），并且设 p 为最短路径。

有两种情况：

如果结点 k 不是路径 p 上的中间结点，则路径 p 上的所有中间结点都属于集合 {1, 2, …, k - 1}。
如果结点 k 是路径 p 上的中间结点，则可将路径 p 分解为两条路径，分别是结点 i 到结点 k 和结点 k 到结点 j 的路径。
（注：开始看到这里的时候，不知道怎么理解。简单来说，就是中间结点选自集合 {1，2，…，k - 1} 的时候的所有结点对的最短路径权重已经知道了，接下来的考虑的中间结点从集合 1，2，…，k - 1，k} 选的时候最短路径权重是多少，只需要考虑路径经过结点 k 的时候权重变化就行了，k 可将 i 到 j 的路径分为两条路径，分别是结点 i 到结点 k 和结点 k 到结点 j 的路径，而这两个的最短路径权重已经知道的（i 到 k 的最短路径的中间结点只能从集合 {1，2，…，k - 1} 选），同理 k 到 j），所以最新的权重选择经过 k 与不经过 k 时的权重较小的那个就行）

所有结点对最短路径问题的一个递归解
设 d(k)ijdij(k) 表示从结点 i 到结点 j 的所有中间结点全部取自集合 {1，2，…，k} 的一条最短路径的权重。k = 0 时，表示结点 i 到结点 j 的路径没有任何中间结点，因此 d(0)ij=wijdij(0)=wij。根据上面的讨论，递归定义如下： 
d(k)ij={wij ， k=0

           min[d(k−1)ij,d(k−1)ik+d(k−1)kj]      ,   k≥1 
------------------------------------------------以上一段描述原文见：https://blog.youkuaiyun.com/ideaqjx/article/details/78881044 

通俗点讲这个算法的过程如下：

先把各点直达的距离算出来，再依次算：

1、如果各点对经过第0个点的，最短距离

2、各点对经过第0,1个点的最短距离。

3、各点对经过第0，1，2个点的最短距离。

........

3、各点对经过第0，1，2 , 3个点的最短距离

---

以此图的矩阵表示法为例

0   3   8    N   -4

N   0   N    1   7

N   4   0    N   N

2   N   -5   0    N

N   N   N   6    0

 

K = 0 时 ,  表示点与点直达的距离

0   1   2    3    4

0     0   3   8    N   -4

1     N   0   N    1   7

2     N   4   0    N   N

3     2   N   -5   0    N

4     N   N   N   6    0

 

K = 1 时表示，点与点经过第一个结点中转，也即下标为0 的点时的最短路径。

以D31为例，D31无直达，但以第0个结点为中转，D30+D01 = 5 ，更新矩阵。

0   1   2    3    4

0     0   3   8    N   -4

1     N   0   N    1   7

2     N   4   0    N   N

3     2   5   -5   0    -2

4     N   N   N   6    0

 

K = 2 时表示，点与点经过第一个与第二个结点中转，也即下标为0，1 的点时的最短路径。

依次类推……

---

代码如下：

图的表示：

public class DigraphMatix {
    //图矩阵
    int [][] matrix ;
    //权值最大值， 表示正无穷
    public final static  int INFINITY = 25536;
    //树的点个数
    int verNum = 0;

    public DigraphMatix(int[][] di) {
        this.matrix = di;
        verNum = di.length;
    }

    public int getVerNum() {
        return verNum;
    }

    public int[][] getMatrix() {
        return matrix;
    }

    public DigraphMatix(int num) {
        matrix = new int[num][num];
        this.verNum = num;
        for (int i = 0; i < verNum; i++) {
            for (int j = 0; j < verNum; j++) {
                if (j == i) {
                    matrix[i][j] = 0;
                }
                matrix[i][j] = INFINITY;
            }
        }
    }
}

算法代码

import java.util.Arrays;

/*
   多源最短路径算法
 */
public class FloydWarshall {
    public int[][] getFolydWarshall(DigraphMatix di) {
        int verNum = di.getVerNum();
        int[][] result = new int[di.getVerNum()][di.getVerNum()];
        for (int i = 0; i < di.getVerNum(); i++) {
            result[i] = Arrays.copyOf(di.getMatrix()[i], di.getVerNum());
        }

        for (int k = 0; k < verNum; k++) {
            for (int i = 0; i < verNum; i++) {
                for (int j = 0; j < verNum; j++) {
                    if (result[i][k] != DigraphMatix.INFINITY &&
                            result[k][j] != DigraphMatix.INFINITY &&
                            result[i][k] + result[k][j] < result[i][j]) {
                        result[i][j] = result[i][k] + result[k][j];
                    }
                }
            }
        }
        return result;
    }
}

测试代码

import org.junit.Test;

import static org.junit.Assert.*;

public class FloydWarshallTest {

    @Test
    public void getFolydWarshall() {
        int inf = DigraphMatix.INFINITY;
        int[][] map = new int[][]{
                  {0, 3, 8, inf, -4}
                , {inf, 0, inf, 1, 7}
                , {inf, 4, 0, inf, inf}
                , {2, inf, -5, 0, inf}
                , {inf, inf, inf, 6, 0}};

        DigraphMatix di = new DigraphMatix(map);
        int [][] result = new FloydWarshall().getFolydWarshall(di);

        for (int i = 0; i < result.length; i++) {
            for (int j = 0; j < result.length; j++) {
                System.out.print(result[i][j]);
                System.out.print(",");
            }
            System.out.println();
        }
    }
}