LeetCode#743 Network Delay Time题解（C++版）

题干

原题网址：
https://leetcode.com/problems/network-delay-time/description/

题干解析

给你一个N个节点的网络拓扑图，以及该拓扑图的的每一条单向边的传递信息的耗时，再给你一个初始节点，从初始节点向整个网络拓扑图“洪泛”信息，问你最早什么时候，每个节点都能接收到信息。

知识点

Dijkstra’s Algorithm（迪克斯特拉算法），图的最短路径

难度

中等

解题思路

其实这道题就是一个求从一个点到其他所有节点的最短路径的问题，只要把那个边的耗时看成边长，然后找出最远的那个节点的距离，即是我们要求的所有节点都收到信息的时长。这道题利用迪杰斯特拉算法就可以求得。具体代码如下

代码

class Solution {
public:
int networkDelayTime(vector<vector<int>>& times, int N, int K) {
    map<int, vector<pair<int, int> > > path; 
    //记录每个节点拥有的路径，距离。第一个参数表示节点编号，第二个参数每一个pair的first是目的节点，second是距离 
    for (int i = 0; i < times.size(); i++) {
        path[times[i][0]].push_back(pair<int, int>(times[i][1], times[i][2]));
    }
    vector<int> gone;  //标记已经算进来的点 
    gone.push_back(K);

    map<int, int> distance;  //标记从源节点到每个点的距离 
    distance[K] = 0;

    bool is_gone[N + 1];
    for (int i = 0; i < N + 1; i++) {
        is_gone[i] = false;
    }
    is_gone[K] = true;

    while (gone.size() < N) {  // 如果还有节点没有被算进来 
        int min = -1;
        int index_i = 0;
        int index_j = 0;

        // 遍历已经算进来的点，找到符合要求的下一个点 
        for (int i = 0; i < gone.size(); i++) {
            for (int j = 0; j < path[gone[i]].size(); j++) {
                if (is_gone[path[gone[i]][j].first]) {
                    continue;
                }
                // LS 
                if (min == -1 || min > (path[gone[i]][j].second + distance[gone[i]])) {
                    min = path[gone[i]][j].second + distance[gone[i]];
                    index_i = i;
                    index_j = j;
                }
            }
        }

        if (min == -1) {  // 如果找不到下个点了，说明不连通 
            return -1;
        } else {  // 找到了则将其加入gone中，并记下此点到源节点的距离 
            gone.push_back(path[gone[index_i]][index_j].first);
            distance[path[gone[index_i]][index_j].first] = path[gone[index_i]][index_j].second + distance[gone[index_i]];
            is_gone[path[gone[index_i]][index_j].first] = true;
        }
    }

    // 找出最远的那个点对应的距离 
    int max = -1;
    for (map<int,int>::iterator it = distance.begin(); it != distance.end(); it++) {
        if (it->second > max) {
            max = it->second;
        }
    } 
    return max;
}
};