学习笔记-弗洛伊德算法

弗洛伊德算法解决最短路径问题

弗洛伊德算法和迪杰斯特拉算法都可以求解最短路径的问题，但区别是迪杰斯特拉会求出某个顶点到其他顶点的最短路径，而弗洛伊德算法会求出各个顶点到各个顶点的最短路径，最终结果采用一个二维表表示，而迪杰斯特拉算法只需要用一维表表示。

最短路径问题

弗洛伊德算法的核心思路

将所有的顶点看作起始点-中间点-终点。如果起始点到中间的的路程加上中间点到终点的路程小于起始点到终点的直接路程，就更新此路程，并记录中间点。
如BAC，如果BA+AC<BC，就更新BC的路程为BA+AC，更新BC的中间点为A。将所有顶点的全部三位组合遍历一遍，就得到了最后的结果。

弗洛伊德算法用到两个二维数组。
dis为一个二维数组，用于存储某点到某点的最短路径，初始化为邻接矩阵，自己到自己表示为0，不直接连通的路表示为一个极大数。
pre为一个二维数组，用于保存从某点如何到某点，初始化每一行都为每一行自己代表的顶点，存储的实际是终点的前驱。

代码

package algorithm;

import java.util.Arrays;

/**
 * 弗洛伊德算法求最短路径
 */
public class floyd {
    public static void main(String[] args) {
        //创建图
        char[] vertex = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int[][] matrix = new int[vertex.length][vertex.length];
        final int N = 65535;
        matrix[0] = new int[]{0, 5, 7, N, N, N, 2};
        matrix[1] = new int[]{5, 0, N, 9, N, N, 3};
        matrix[2] = new int[]{7, N, 0, N, 8, N, N};
        matrix[3] = new int[]{N, 9, N, 0, N, 4, N};
        matrix[4] = new int[]{N, N, 8, N, 0, 5, 4};
        matrix[5] = new int[]{N, N, N, 4, 5, 0, 6};
        matrix[6] = new int[]{2, 3, N, N, 4, 6, 0};
        FloydGraph graph = new FloydGraph(vertex, matrix);
        graph.show();
        graph.floyd();
        graph.show();

    }
}

//图
class FloydGraph {
    public char[] vertex;//顶点集合
    public int[][] dis;//邻接矩阵,最后存储各个顶点的最短距离
    public int[][] pre;//存储两顶点路径的中间点

    public FloydGraph(char[] vertex, int[][] dis) {
        this.vertex = vertex;
        this.dis = dis;
        this.pre = new int[vertex.length][vertex.length];
        for (int i = 0; i < pre.length; i++) {
            Arrays.fill(pre[i], i);
        }
    }

    //展示图
    public void show() {
        for (int i = 0; i < dis.length; i++) {
            for (int j = 0; j <dis.length ; j++) {
                System.out.printf("%10d\t",dis[i][j]);
            }
            System.out.println();
        }
        for (int i = 0; i < pre.length; i++) {
            for (int j = 0; j < pre[i].length; j++) {
                System.out.print(vertex[pre[i][j]] + "\t");
            }
            System.out.println();
        }

    }

    /**
     * 弗洛伊德算法
     */
    public void floyd(){
        int len;
        //中间点
        for (int i = 0; i <vertex.length ; i++) {
            //起始点
            for (int j = 0; j <vertex.length ; j++) {
                //终点
                for (int k = 0; k <vertex.length ; k++) {
                    len=dis[j][i]+dis[i][k];
                    if(len<dis[j][k]){
                        dis[j][k]=len;
                        //jk点通过i离k的最近点
                        pre[j][k]=pre[i][k];
                    }
                }
            }
        }
    }


}

要注意的是：

三层for循环的顺序是：先中间点后起始点后终点。

pre[j][k]=pre[i][k]而不是pre[j][k]=i（为什么呢？实际上pre二维数组是在存储某点如何到达某点，也就是列标识的顶点如何到达行标识的顶点，当要找到A如何到D最短时，查询pre[A][D]如果是F，接着查询pre[A][F]{A如何到F}如果是G，查询pre[A][G]{A如何到G}，如果是A，说明AG直连，那么一条最短路径是AGFD，实际是在目标行递归查询的过程，而更新时进入if条件，说明jik是最短的，那么j应该通过i到k的最短点到k（pre存储的是终点的前驱）（如果ik直连的距离大于ik中转的距离，直接存储i的话就不是最近点了，而是通过中转比较近，pre[i][k]如果直连最近就指向自己i，否则就指向最近的中转点），这个操作是为了向后收束住路径表，使得查询时可以在一行内查询）（换句话说，之所以要更新是因为AB+BC的距离小于AC,而BC的距离不一定是B到C的距离，也可能是BD+DC的距离，所以不能直接记录B，这样一来最终表格里记录的起点到终点的中转点必定是与终点直接相连的）

不用写dis[k][j]=len,因为三层循环会将所有可能遍历，cab和bac都会分别遍历，就不需要同时更新了。