743. Network Delay Time

最新推荐文章于 2020-10-23 21:03:23 发布

原创最新推荐文章于 2020-10-23 21:03:23 发布 · 196 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

230 篇文章

订阅专栏

本文介绍了一个有向图问题，计算从指定源节点发送信号到所有节点的最短时间。使用Dijkstra算法找到从源节点到每个节点的最短路径，并返回最长的时间作为最终结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

There are N network nodes, labelled 1 to N.

Given times, a list of travel times as directed edges times[i] = (u, v, w), where u is the source node, v is the target node, and w is the time it takes for a signal to travel from source to target.

Now, we send a signal from a certain node K. How long will it take for all nodes to receive the signal? If it is impossible, return -1.

Note:

N will be in the range [1, 100].
K will be in the range [1, N].
The length of times will be in the range [1, 6000].
All edges times[i] = (u, v, w) will have 1 <= u, v <= N and 1 <= w <= 100.

给出一个有向图，表示网络。计算从一个网络结点发送信息到每个结点都收到信息的最短时间。因为信息是可以同时在不同路径上传输的，所以每个节点都收到信息的最短时间由最晚收到信息的结点决定。计算从源结点发送信息到各个节点的最短时间，其中的最大值即为答案。本实现使用dijkstra算法。

代码：

class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K) {
        int result = 0;
        vector<vector<int>> edges(N, vector<int>(N, INT_MAX));
        for(auto t:times) {
            edges[t[0]-1][t[1]-1] = t[2];
        }
        --K;

        // dijkstra
        vector<bool> visited(N, false);
        visited[K] = true;
        vector<int> costs(N);
        for(int i = 0; i < N; ++i) {
            costs[i] = edges[K][i];
        }
        for(int i = 0; i < N-1; ++i) {
            int min_val = INT_MAX, idx = -1;
            for(int j = 0; j < N; ++j) {
                if(costs[j] < min_val && !visited[j]) {
                    min_val = costs[j];
                    idx = j;
                }
            }
            if(idx == -1) {
                return -1;
            }
            visited[idx] = true;
            for(int j = 0; j < N; ++j) {
                if(costs[idx] < INT_MAX && edges[idx][j] < INT_MAX && costs[idx] + edges[idx][j] < costs[j]) {
                    costs[j] = costs[idx] + edges[idx][j];
                }
            }
        }

        for(int i = 0; i < N; ++i) {
            if(i == K) continue;
            result = max(costs[i], result);
        }
        return result;
    }
};