LeetCode 743 网络延迟时间[最短路径 迪杰斯特拉 Floyd] HERODING的LeetCode之路

Posted 2021-08-31 HERODING23

解题思路：
说实话，一开始我并没有注意到这是一道最短路径问题，我的想法很简单，首先是思考用DFS还是BFS解决，本来想两种方法都尝试的，结果在DFS就碰壁了，一个是编写完代码后测试用例发现路径的权重会导致直连的耗时可能比间接连接的要长，第二个可能会出现封闭路径死循环的情况，这让意识到，普通的DFS或者BFS是解决不了这类问题的，这就是我心心念念已久的最短路径问题啊！迪杰斯特拉、Floyd这不整上？！

Floyd

第一个方法使用Floyd的经典最短路径算法，其核心思想是固定一个点为中间点，求两点之间最短距离，首先初始化图网络数组，并且更新各点之间的距离，接着就使用其核心思想更新路径，最后从k点出发，计算到各点的最远距离，如果有无法到达的点，直接返回-1，都能到达，返回最大值，代码如下：

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        // 定义图
        vector<vector<long long>> graph(n + 1, vector<long long>(n + 1, INT_MAX));
        // 初始化图中节点的距离
        for(int i = 1; i <= n; i ++) {
            graph[i][i] = 0;
        }
        for(auto& time : times) {
            graph[time[0]][time[1]] = time[2];
        }

        // floyed算法核心：固定一个点为中间点，求两点之间最短距离
        for(int k = 1; k <= n; k ++) {
            for(int i = 1; i <= n; i ++) {
                for(int j = 1;j <= n; j ++) {
                    graph[i][j] = min(graph[i][j], graph[i][k] +graph[k][j]);
                }
            }
        }
        int ans = 0;
        for(int i = 1; i <= n; i ++) {
            // k到i点没有路径
            if(graph[k][i] == INT_MAX) {
                return -1;
            }
            ans = max(ans, (int)graph[k][i]);
        }
        return ans;
    }
};

不过这种方法在解决该题的弊端还是很明显的，就是计算了不需要的数据，Floyd算法可以得到所有的点到其他点的最短距离，而这道题中我们只需要一个点到其他点的距离，所以下面介绍一下迪杰斯特拉算法的应用。

迪杰斯特拉

迪杰斯特拉算法使用的数据结构更多，实现起来相对于Floyd更复杂，但是对解决单点的问题更有针对性，迪杰斯特拉算法的核心在于将点分为访问过和未访问过，每次都将最短路径上的点加入访问队列，并更新到别的的点的距离（该距离是标记点到该点点的最短路径距离），实现过程中，首先要定义图网络数组、最短路径数组和访问数组，并对其进行初始化，初始化完成后，进行n次遍历，目的是保证所有点都被访问到，然后找最短路径上的点，找到后更新访问数组，再使用上述介绍的核心内容，最后从k点出发，根据distance数组统计最长路径，如果有无法到达的点，直接返回-1，都能到达，返回最大值，代码如下:

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k) {
        // 定义图和访问数组、距离数组
        vector<vector<long long>> graph(n + 1, vector<long long>(n + 1, INT_MAX));
        vector<long long> distance(n + 1, INT_MAX); 
        vector<bool> visited(n + 1, false);
        distance[k] = 0;
        // 初始化图中节点的距离
        for(int i = 1; i <= n; i ++) {
            graph[i][i] = 0;
        }
        for(auto& time : times) {
            graph[time[0]][time[1]] = time[2];
        }
        
        // n个点，遍历n次
        for(int i = 0; i < n;i ++) {
            int index = -1, minNum = INT_MAX;
            // 找最近的点
            for(int j = 1; j <= n; j ++) {
                if(!visited[j] && distance[j] < minNum) {
                    index = j;
                    minNum = distance[j]; 
                }
            }
            // 都遍历过直接退出
            if(index == -1) {
                break;
            }
            // 标记当前点访问过
            visited[index] = true;
            // 更新到别的点的最短距离
            for(int v = 1; v <= n; v ++) {
                if(!visited[v] && graph[index][v] != INT_MAX) {
                    if(distance[index] + graph[index][v] < distance[v]) {
                        distance[v] = distance[index] + graph[index][v];
                    }
                }
            }
        }
        
        int ans = 0;
        for(int i = 1; i <= n; i ++) {
            // k到i点没有路径
            if(distance[i] == INT_MAX) {
                return -1;
            }
            ans = max(ans, (int)distance[i]);
        }
        return ans;
    }
};