743. Network Delay Time

最新推荐文章于 2020-12-29 18:08:08 发布

原创最新推荐文章于 2020-12-29 18:08:08 发布 · 367 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode-java

leetcode 专栏收录该内容

599 篇文章

订阅专栏

本文介绍如何使用迪杰斯特拉算法解决网络信号传播延迟问题。通过构建图并利用优先队列，实现从源节点到所有目标节点的最短路径计算。文章提供了一种基本实现方案，适用于节点数量较小的情况。

摘要生成于 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.

Intuition and Algorithm

We use Dijkstra’s algorithm to find the shortest path from our source to all targets. This is a textbook algorithm, refer to this link for more details.

Dijkstra’s algorithm is based on repeatedly making the candidate move that has the least distance travelled.

In our implementations below, we showcase both O(N^2) (basic) and O(NlogN) (heap) approaches.

Basic Implementation

class Solution {
    public int networkDelayTime(int[][] times, int N, int K) {
        Map<Integer, List<int[]>> graph = new HashMap();
        for (int[] edge: times) {
            if (!graph.containsKey(edge[0]))
                graph.put(edge[0], new ArrayList<int[]>());
            graph.get(edge[0]).add(new int[]{edge[1], edge[2]});
        }
        PriorityQueue<int[]> heap = new PriorityQueue<int[]>(
                (info1, info2) -> info1[0] - info2[0]);
        heap.offer(new int[]{0, K});

        Map<Integer, Integer> dist = new HashMap();

        while (!heap.isEmpty()) {
            int[] info = heap.poll();
            int d = info[0], node = info[1];
            if (dist.containsKey(node)) 
                continue;
            dist.put(node, d);
            if (graph.containsKey(node))
                for (int[] edge: graph.get(node)) {
                    int nei = edge[0], d2 = edge[1];
                    if (!dist.containsKey(nei))
                        heap.offer(new int[]{d+d2, nei});
                }
        }

        if (dist.size() != N)
            return -1;
        int ans = 0;
        for (int cand: dist.values())
            ans = Math.max(ans, cand);
        return ans;
    }
}