最短路径算法：弗洛伊德（Floyd-Warshall）算法

一、算法介绍

　　Floyd-Warshall算法（英语：Floyd-Warshall algorithm），中文亦称弗洛伊德算法，是解决任意两点间的最短路径的一种算法，可以正确处理有向图或负权（但不可存在负权回路）的最短路径问题，同时也被用于计算有向图的传递闭包。Floyd-Warshall算法的时间复杂度为 O(N³)，空间复杂度为 O(N²)，因时间复杂度比较高，不适合计算大量数据。

二、算法原理

Floyd-Warshall算法的原理是动态规划，Floyd算法适用于APSP(All Pairs Shortest Paths，多源最短路径)。

设 D_i,j,k 为从 i 到 j 的只以 (1..k) 集合中的节点为中间节点的最短路径的长度。

1. 若最短路径经过点 k，则 D_i,j,k = D_i,k,k-1 + D_k,j,k-1；
2. 若最短路径不经过点 k，则 D_i,j,k =D_i,j,k-1。

因此，D_i,j,k = min (D_i,j,k-1, D_i,k,k-1 + D_k,j,k-1)。

        for (k = 0; k < V; k++) {
            for (i = 0; i < V; i++) {
                for (j = 0; j < V; j++) {
                    if (dist[i][j] > dist[i][k] + dist[k][j]) {
                        dist[i][j] = dist[i][k] + dist[k][j];
                    }
                }
            }
        }

输入矩阵：

    int[][] graph = {
                {0,   5,  INF, 10},
                {INF, 0,   3, INF},
                {INF, INF, 0,   1},
                {INF, INF, INF, 0}
    };

输出结果：

　　Shortest distance matrix : 
      0      5      8      9
    INF      0      3      4
    INF    INF      0      1
    INF    INF    INF      0

　　初始化与输入图矩阵相同的求解矩阵。然后，我们通过将所有顶点视为中间顶点来更新解矩阵。这个思想是一个接一个地选取所有顶点并更新所有最短路径，其中包括所选取的顶点作为最短路径中的中间顶点。

源代码：

package algorithm.shortestpath;

public class AllPairShortestPath {
    final static int INF = 99999, V = 4;

    public void floydWarshall(int[][] graph) {
        int[][] dist = new int[V][V];
        int i, j ,k;
        for (i = 0; i < V; i++) {
            for (j = 0; j < V; j++) {
                dist[i][j] = graph[i][j];
            }
        }
        for (k = 0; k < V; k++) {
            for (i = 0; i < V; i++) {
                for (j = 0; j < V; j++) {
                    if (dist[i][j] > dist[i][k] + dist[k][j]) {
                        dist[i][j] = dist[i][k] + dist[k][j];
                    }
                }
            }
        }
        printSoultion(dist);
    }

    private void printSoultion(int[][] dist) {
        System.out.println("The following matrix shows the shortest "+
                "distances between every pair of vertices");
        for (int i = 0; i < V; ++i) {
            for (int j = 0; j < V; ++j) {
                if (dist[i][j] == INF) {
                    System.out.print("INF ");
                } else {
                    System.out.print(dist[i][j] + "   ");
                }
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        /* 输入带权重矩阵
               10
         (0)------->(3)
          |         /|\
        5 |          |
          |          | 1
         \|/         |
         (1)------->(2)
               3           */
        int[][] graph = {
                {0,   5,  INF, 10},
                {INF, 0,   3, INF},
                {INF, INF, 0,   1},
                {INF, INF, INF, 0}
        };

        AllPairShortestPath a = new AllPairShortestPath();

        a.floydWarshall(graph);
    }
}