Floyd(弗洛伊德)算法

一.简介

弗洛伊德算法寻找多源点最短路径的算法，即所有节点之间最短路径。

二.实现

package com.vincent;


import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        char[] datas = {'a','b','c','d','e','f'};
        int[][] graph = new int[datas.length][];

        final int M = Integer.MAX_VALUE;
        //M表示节点之间没有直接连通,当前节点与当前节点路径长度为0
        graph[0] = new int[]{0,2,3,M,M,5};
        graph[1] = new int[]{2,0,M,4,M,M};
        graph[2] = new int[]{3,M,0,M,5,M};
        graph[3] = new int[]{M,4,M,0,M,6};
        graph[4] = new int[]{M,M,5,M,0,8};
        graph[5] = new int[]{5,M,M,6,8,0};

        for(int i=0;i<datas.length;i++){
            System.out.println(Arrays.toString(graph[i]));
        }

        System.out.println();
        floyd(graph,datas);
        for(int i=0;i<datas.length;i++){
            System.out.println(Arrays.toString(graph[i]));
        }
    }

    /**
     *弗洛伊德算法
     * @param graph         图的邻接矩阵
     * @param datas         节点值
     * @return
     */
    public static void floyd(int[][] graph,char[] datas){
        //原理：
        //设L(v,u)表示节点v到节点u的直接路径，则L(v,k) + L(k,u) 也是节点v到节点u的路径长度
       for(int k=0;k<graph.length;k++) {//中间节点
           for (int i=0;i<datas.length;i++) {//开始节点
               for(int j=0;j<datas.length;j++){//结束节点
                   int dis = graph[i][k] + graph[k][j];
                   //防止计算溢出
                   if(graph[i][k] == Integer.MAX_VALUE || graph[k][j] == Integer.MAX_VALUE){
                       dis = Integer.MAX_VALUE;
                   }
                   if(dis < graph[i][j]){
                       graph[i][j] = dis;
                   }
               }
           }
       }
    }
}

效果：

三.总结

Floyd(弗洛伊德)算法时间复杂度为O(n ^ 3)