最短路径算法

1.单源点最短路径

单源点路径算法的核心：根据松弛原理，在两个顶点之间查找第三个顶点，使其距离最短。用到的都是DP的思想

1.1 迪杰特斯拉Dijkstra

以出发点为中心，向四周进行扩散，每次将当层的节点作为(i,j)最短距离的第三个顶点k，若加入第三个顶点k后满足(i,j) > (i,k) + (k,j)，则更新(i,j) = (i,k) + (k,j).

核心：每次查找最短距离的点

1.2 Bellman-Ford算法

跟Dijkstra算法的思路一致，不过，该算法以查找最短边为核心

2.多源点最短路径

2.1 弗洛伊德

弗洛伊德算法的本质也是松弛原理，整体时间的复杂度为O(n^3)，不管是单源点还是多源点问题，个人比较喜欢直接采用弗洛伊德算法直接求解，算法的整体思路比较简单。

注意：中间点的循环部分必须放在最外层，原因在于：如果放在内层，极有可能出现当我们利用第三个点k更新两个点(i,j)之间的距离时，之前的(i,k)和(k,j)之间的最短路径还未优化。最外层的循环实际上是更新状态转移的点

具体原因可以参考Floyd算法为什么把k放在最外层

具体应用：网络延迟时间，我之前将k放在第二层，调试了半天也搞不清楚啥原因导致无法AC，后来才知道k一定要放在最外层，这是状态转移的点，可以确保在更新两个点之间的最短距离之前，之前的最短距离已经更新到。

我采用比较直观的写法，空间复杂度比较高。大家可以在我的基础上，将z放在中间层，就会发现是无法AC的，其实就是前面所说的：更新两个点之间的最短距离之前，之前的最短距离还未更新到。

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        return floyd(times, N, K);
    }
    int floyd(vector<vector<int>>& times, int N, int K) {
        const int MAX_DISTANCE = 6001;
        //构造图的矩阵
        vector<vector<int>> graph(N+1, vector<int>(N+1, MAX_DISTANCE));
        for (auto& time: times) {
            graph[time[0]][time[1]] = time[2];
        }

        for (int z = 1; z <= N; ++z) { //一定要放在最外层
            for (int x = 1; x <= N; ++x) {
                for (int y = 1; y <= N; ++y) {
                    if (graph[x][z] + graph[z][y] < graph[x][y]) {
                        graph[x][y] = graph[x][z] + graph[z][y];
                    }
                }
            }
        }

        int go_time = INT_MIN;
        for (int vex = 1; vex <= N; ++vex) {
            if (vex == K) continue;
            if (graph[K][vex] >= MAX_DISTANCE)
                return -1;
            go_time = max(go_time, graph[K][vex]);
        }
        return go_time;
    }
};

3.参考

[1]网络延迟时间

[2]Bellman-Ford和Dijkstra算法