Bellman-Ford、Dijkstra、Floyd算法

Bellman-Ford算法

Bellman-Ford用于找出单源最短路径，即从源节点到图中每个节点的最短路径，支持边权重为负的情况。
算法利用了动态规划的思想，实现简单，但时间复杂度为$O(VE)$，非常高。

解决的问题

1. 从A出发是否可以到达各个节点
2. 从A出发到达各个节点的最短路径
3. 图中是否存在负环路（权重之和为负数）

思路

1. 初始化：对图中所有节点v，设置dist(v)=infinite，设置dist(src)=0
2. 接下来进行N-1次松弛操作，对于每次松弛操作：
   遍历所有的边(u, v)，如果dist(u) + w(u, v) < dist(v)，则更新dist(v)
   重复执行N-1次松弛操作可以理解为，每次从src出发，允许绕多一个节点，是否能够得到从src到v更短的路径
3. 最后如果再进行一次松弛操作，还能找到从src到v更短的路径的话，说明存在负环路
   如果存在负环路，则Bellman-Ford算法不支持计算出到各个节点的最短路径

leetcode例题

https://leetcode-cn.com/problems/cheapest-flights-within-k-stops/
这道题目中限制K次中转可以理解为限制Bellman-Ford算法中的松弛次数，因此用二维dp即可解决：

class Solution {
public:
    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
        int cost[n][k + 1];
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j <= k; ++j) {
                cost[i][j] = INT_MAX;
            }
        }
        for (int j = 0; j <= k; ++j) {
            cost[src][j] = 0;
        }
        for (auto& flight : flights) {
            int u = flight[0], v = flight[1], w = flight[2];
            if (u == src) {
                cost[v][0] = w;
            }
        }
        for (int j = 1; j <= k; ++j) {
            for (auto& flight : flights) {
                int u = flight[0], v = flight[1], w = flight[2];
                if (cost[u][j - 1] != INT_MAX) {
                    cost[v][j] = min(cost[v][j], cost[u][j - 1] + w);
                }
            }
        }
        return cost[dst][k] != INT_MAX ? cost[dst][k] : -1;
    }
};

Dijkstra算法

Dijkstra算法同样用于找出单源最短路径，但它不适用于存在负权边的情况。

解决的问题

1. 从A出发是否可以到达各个节点
2. 从A出发到达各个节点的最短路径

思路

算法的主要思想是：
把图中节点分成两个集合，第一组为已求出最短路径的节点集合S（初始时只有src），第二组为未确定最短路径的节点集合U，按最短路径长度的递增次序依次把U中的顶点加入S。

1. 初始时S={src}，dist(src)=0，U={其余节点}。对于src能直接到达的节点m，设置dist(m)=w(src, m)；对于其他节点，把dist设为infinite
2. 从U中选一个dist(v)最小的节点v，把v加入S
3. 以v作为中间节点更新U中各节点的距离：若w(v, u) + dist(v) < dist(u)，则更新dist(u)
4. 重复2、3步骤直至所有节点被加入S

leetcode例题

https://leetcode-cn.com/problems/network-delay-time/
使用邻接矩阵建图的方式，采用visited数组来简单暴力地寻找节点v：

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        int dist[n];
        for (int i = 0; i < n; ++i) dist[i] = INT_MAX / 2;
        dist[k - 1] = 0;
        // 邻接矩阵建图,graph[i][j] < INT_MAX / 2就表示有边
        vector<vector<int>> graph(n, vector<int>(n, INT_MAX / 2));
        for (auto& edge : times) {
            graph[edge[0] - 1][edge[1] - 1] = edge[2];
            if (edge[0] == k) {
                dist[edge[1] - 1] = edge[2];
            }
        }
        bool visited[n];
        memset(visited, false, sizeof(visited));
        visited[k - 1] = true;
        int ans = 0;
        for (int i = 1; i < n; ++i) {
            // 找U集合中dist[v]最小的v
            int v = -1;
            for (int j = 0; j < n; ++j) {
                if (!visited[j] && (v == -1 || dist[j] < dist[v])) {
                    v = j;
                }
            }
            visited[v] = true;
            // v被选出来后,dist[v]不会再变化
            ans = max(ans, dist[v]);
            // 利用v去更新可能的dist[u]
            for (int u = 0; u < n; ++u) {
                dist[u] = min(dist[u], dist[v] + graph[v][u]);
            }
        }
        return ans == INT_MAX / 2 ? -1 : ans;
    }
};

采用邻接矩阵的方式实现，时间复杂度为$O(n^2)$。

Floyd算法

Floyd算法用于找出图中任意两点间的最短路径，它也支持边权重为负的情况。
算法同样利用了动态规划的思想，非常容易实现，时间复杂度是$O(n^3)$，空间复杂度$O(n^2)$。

解决的问题

1. 从节点i是否可以到达节点j
2. 从节点i到达节点j的最短路径

思路

1. 初始时，dist[i][i] = 0，dist[i][j] = w(i, j)（如果有边）
2. 对于每一对节点i和j，寻找节点k，使得dist[i][k] + dist[k][j] < dist[i][j]，并更新dist[i][j]

leetcode例题

https://leetcode-cn.com/problems/network-delay-time/

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        vector<vector<int>> dist(n, vector<int>(n, INT_MAX / 2));
        for (auto& edge : times) {
            dist[edge[0] - 1][edge[1] - 1] = edge[2];
        }
        for (int i = 0; i < n; ++i) {
            dist[i][i] = 0;
        }
        for (int k = 0; k < n; ++k) {
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
                }
            }
        }
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            ans = max(ans, dist[k - 1][i]);
        }
        return ans == INT_MAX / 2 ? -1 : ans;
    }
};