743. 网络延迟时间

题目：

有 N 个网络节点，标记为 1 到 N。

给定一个列表 times，表示信号经过有向边的传递时间。 times[i]= (u, v, w)，其中 u 是源节点，v 是目标节点， w 是一个信号从源节点传递到目标节点的时间。

现在，我们向当前的节点 K 发送了一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1。

思路：本质上是求单点到所有其他点的最短距离，最后去最短距离中的最大值。

如果有点的值为初始的MAX值，就返回-1；

单点求到其他点的最短距离可以用Dijstra或者Floyd-Warshall 算法

前者的思路是按层一个一个的去遍历，每次都选取未访问过的节点加入到队列中

后者就是遍历每个边点关系，遍历V-1次

class Solution {
public:
    int networkDelayTime(vector>& times, int N, int K) {
        int res = 0;
        vector> edges(101, vector(101, -1));
        queue q{{K}};
        vector dist(N + 1, INT_MAX);
        dist[K] = 0;
        for (auto e : times) edges[e[0]][e[1]] = e[2];
        while (!q.empty()) {
            unordered_set visited;
            //一层一层的进行
            for (int i = q.size(); i > 0; --i)
            {
                int u = q.front(); q.pop();
                for (int v = 1; v <= 100; ++v) 
                {
                    if (edges[u][v] != -1 && dist[u] + edges[u][v] < dist[v])
                    {
                        if (!visited.count(v)) {
                            visited.insert(v);
                            q.push(v);
                                                         }
                        dist[v] = dist[u] + edges[u][v];
                    }
                }
            }
        }
        for (int i = 1; i <= N; ++i) {
            res = max(res, dist[i]);
        }
        return res == INT_MAX ? -1 : res;
    }
};

第二种：

class Solution {
public:
    int networkDelayTime(vector>& times, int N, int K) {
        int res = 0;
        vector dist(N + 1, INT_MAX);
        dist[k] = 0;
        for (int i = 1; i < N; ++i) {
            for (auto e : times) {
                int u = e[0], v = e[1], w = e[2];
                if (dist[u] != INT_MAX && dist[v] > dist[u] + w) {
                    dist[v] = dist[u] + w;
                }
            }
        }
        for (int i = 1; i <= N; ++i) {
            res = max(res, dist[i]);
        }
        return res == INT_MAX ? -1 : res;
    }
};