LeetCode : 743. 网络延迟时间（Network Delay Time）解答，有权最短路径问题

最新推荐文章于 2023-05-21 20:36:50 发布

阿飞__

最新推荐文章于 2023-05-21 20:36:50 发布

阅读量3.1k

点赞数 2

分类专栏： LeetCode 文章标签： LeetCode 743. Network Delay Time

本文链接：https://blog.csdn.net/afei__/article/details/83780362

版权

LeetCode 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

743. 网络延迟时间

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

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

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

注意：

N 的范围在 [1, 100] 之间。
K 的范围在 [1, N] 之间。
times 的长度在 [1, 6000] 之间。
所有的边 times[i] = (u, v, w) 都有 1 <= u, v <= N 且 1 <= w <= 100。

一、思路

首先，这是一道有权图求最短路径的问题，且边的权重不存在负数，所以选择使用 狄克斯特拉算法（dijkstra）。
狄克斯特拉算法介绍：有权最短路径问题：狄克斯特拉(Dijkstra)算法 & Java 实现
由于狄克斯特拉算法中，我们总是需要从 剩余节点 中取出一个 距离起点最近 的节点出来，并更新它能到达的节点的距离。所以我们选择使用一个 优先队列 保存剩余节点，可以节约我们获取距离起点距离最近节点的耗时。
最后，我们取出所有节点中距离起点最远的一个节点的距离，即耗时最长的节点。
如果这个值是 Integer.MAX_VALUE，则说明无法到达这个节点，返回 -1。

二、实现

详细代码说明参考注释吧~

import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;

/**
 * Copyright © 2018 by afei. All rights reserved.
 * 
 * @author: afei
 * @date: 2018年11月5日
 */

public class Solution {

    public static void main(String[] args) {
        int[][] times = { { 2, 1, 1 }, { 2, 3, 1 }, { 3, 4, 1 } };
        int[][] times2 = { { 1, 2, 1 }, { 2, 3, 7 }, { 1, 3, 4 }, { 2, 1, 2 } };
        System.out.println(networkDelayTime(times, 4, 2));
        System.out.println(networkDelayTime(times2, 4, 1));
    }

    public static int networkDelayTime(int[][] times, int N, int K) {
        // 这道题中 N 个节点下标都是连续的，其实放在一个数组中效率更好。考虑通用性我还是使用 map 了
        HashMap<Integer, NetNode> map = new HashMap<>();
        // 这个优先队列保存剩余节点，并按照 distance 从小到大排序
        PriorityQueue<NetNode> queue = new PriorityQueue<>(N, (o1, o2) -> o1.distance - o2.distance);
        // Step 1: init
        for (int i = 1; i <= N; i++) {
            NetNode node = new NetNode(i);
            if (i == K) {
                node.distance = 0;
            }
            map.put(i, node);
            queue.offer(node);
        }
        // Step 2: update neighbor node
        for (int i = 0; i < times.length; i++) {
            NetNode node = map.get(times[i][0]);
            node.neighbors.put(times[i][1], times[i][2]);
        }
        // Step 3: dijkstra
        while (!queue.isEmpty()) {
            // extract min
            NetNode min = queue.poll(); // 优先队列的队首就是 distance 最小的节点
            if (min.distance == Integer.MAX_VALUE) {
                return -1; // 无法到达的点，后面步骤都可以不做了，直接 return
            }
            // Step 4: relax
            // 所谓 relax，即是取出 min 节点后，更新其可以到达的节点的 distance
            for (int v : min.neighbors.keySet()) {
                NetNode curr = map.get(v);
                int distance = min.distance + min.neighbors.get(v);
                if (distance < curr.distance) {
                    curr.distance = distance;
                    // Step 5: update queue
                    // 更新节点在队列中的位置，由于没有直接的更新方法，只好先取出来再放进去
                    queue.remove(curr);
                    queue.add(curr);
                }
            }
        }
        // Step 6: find max
        int max = 0;
        for (Map.Entry<Integer, NetNode> entry : map.entrySet()) {
            if (entry.getValue().distance > max) {
                max = entry.getValue().distance;
            }
        }
        return max;
    }

    public static class NetNode {
        int u;
        HashMap<Integer, Integer> neighbors = new HashMap<>();
        int distance = Integer.MAX_VALUE;

        public NetNode(int u) {
            this.u = u;
        }
    }
}