网络延迟时间_华为OD_网络病毒传染

最新推荐文章于 2024-09-14 21:48:00 发布

朱子鱼

最新推荐文章于 2024-09-14 21:48:00 发布

阅读量381

点赞数 8

分类专栏：算法 Java 华为OD 文章标签：华为od java

本文链接：https://blog.csdn.net/qq_42537461/article/details/135251746

版权

算法同时被 3 个专栏收录

11 篇文章 0 订阅

订阅专栏

Java

4 篇文章 0 订阅

订阅专栏

华为OD

2 篇文章 0 订阅

订阅专栏

网络延迟时间

题目描述

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

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

现在，从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1 。

示例 1：

输入：times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
输出：2

示例 2：

输入：times = [[1,2,1]], n = 2, k = 1
输出：1

示例 3：

输入：times = [[1,2,1]], n = 2, k = 2
输出：-1

提示：

1 <= k <= n <= 100
1 <= times.length <= 6000
times[i].length == 3
1 <= ui, vi <= n
ui != vi
0 <= wi <= 100
所有 (ui, vi) 对都 互不相同（即，不含重复边）

题目分析

可以转换为树求最短路径Dijkstra。思想为贪心。即先找到第一个点到下一个点的最短路径，不可到达的都为空。然后再这些路径中找的一个最短的作为下一个可以到达的最短路径。依次将其放入小根堆中，因此每次弹出来的就都是这个点最小的路径，如果有路径已经使用过后，就可以跳过。

public int networkDelayTime(int[][] times, int n, int k) {
       List<int[]>[] nexts = new List[n];
        for (int i=0;i<n;i++){
            nexts[i] = new ArrayList<>();
        }
        for (int[] edge:times) {
            nexts[edge[0]-1].add(new int[]{edge[1]-1,edge[2]});
        }
        boolean[] used = new boolean[n];
        int max = -1;
        int count = 0;
        PriorityQueue<int[]> heap = new PriorityQueue<>((o1,o2)->o1[1]-o2[1]);
        heap.offer(new int[]{k-1,0});
        while (!heap.isEmpty()&&count<n){
            int[] poll = heap.poll();
            int distan = poll[1];
            int node = poll[0];
            if(used[node]){
                continue;
            }
            count++;
            max = Math.max(max,distan);
            used[node] = true;
            for (int[] next : nexts[node]) {
                if(!used[next[0]]){
                    heap.offer(new int[]{next[0],distan+next[1]});
                }
            }
        }
        return count<n?-1:max;
    }