743. 網路延遲時間

有 N 個網路節點，標記為 1 到 N。

給定一個列表 times，表示訊號經過 有向 邊的傳遞時間。 times[i] = (u, v, w)，其中 u 是源節點，v 是目標節點， w 是一個訊號從源節點傳遞到目標節點的時間。

現在，我們向當前的節點 K 傳送了一個訊號。需要多久才能使 所有節點（共 N 個節點）都收到訊號？如果不能使所有節點收到訊號，返回 -1。

注意：

1. N 的範圍在 [1, 100] 之間。
2. K 的範圍在 [1, N] 之間。
3. times 的長度在 [1, 6000] 之間。
4. 所有的邊 times[i] = (u, v, w) 都有 1 <= u, v <= N
   且 1 <= w <= 100。

一、思路

1. 首先，這是一道有權圖求最短路徑的問題，且邊的權重不存在負數，所以選擇使用 狄克斯特拉演算法（dijkstra）。 狄克斯特拉演算法介紹：有權最短路徑問題：狄克斯特拉(Dijkstra)演算法 & Java 實現
2. 由於狄克斯特拉演算法中，我們總是需要從 剩餘節點 中取出一個 距離起點最近 的節點出來，並更新它能到達的節點的距離。所以我們選擇使用一個 優先佇列 儲存剩餘節點，可以節約我們獲取距離起點距離最近節點的耗時。
3. 最後，我們取出所有節點中距離起點最遠的一個節點的距離，即耗時最長的節點。
4. 如果這個值是 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()) {
            // extra 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;
        }
    }
}

三、專案地址

四、原題地址