743. 网络延迟时间

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/network-delay-time
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

同改题

import java.util.*;

class Solution {
    public int networkDelayTime(int[][] times, int n, int k) {
        Gragh gragh = new Gragh();
        gragh.buildGragh(times);

        Map<Integer, Integer> distanceMap = new HashMap<>();
        distanceMap.put(k, 0);
        Set<Integer> visited = new HashSet<>();
        PriorityQueue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(distanceMap.get(o1), distanceMap.get(o2));
            }
        });

        queue.offer(k);

        while (!queue.isEmpty()) {
            int from = queue.poll();
            visited.add(from);
            for (Gragh.Edge edge : gragh.buildNode(from).nexts) {
                int to = edge.to.value;
                if (!visited.contains(to)) {
                    Integer distance = distanceMap.get(to);
                    if (distance == null || distance > distanceMap.get(from) + edge.weight) {
                        distance = distanceMap.get(from) + edge.weight;
                        distanceMap.put(to, distance);
                        queue.offer(to);
                    }
                }
            }
        }

        if (distanceMap.size() < n) {
            return -1;
        }

        int ret = Integer.MIN_VALUE;

        for (Map.Entry<Integer, Integer> entry : distanceMap.entrySet()) {
            ret = Math.max(ret, entry.getValue());
        }

        return ret;
    }
}

class Info {
    int index;
    int value;

    public Info(int index, int value) {
        this.index = index;
        this.value = value;
    }
}

class Gragh {

    private Map<Node, Map<Node, Edge>> edgeMap = new HashMap<>();

    private Map<Integer, Node> nodeMap = new HashMap<>();

    private List<Edge> edges = new ArrayList<>();

    class Node {
        int value;
        int in;
        int out;
        List<Edge> nexts = new ArrayList<>();

        public Node(int value) {
            this.value = value;
        }
    }

    class Edge {
        Node from;
        Node to;
        int weight;

        public Edge(Node from, Node to, int weight) {
            this.from = from;
            this.to = to;
            this.weight = weight;
        }
    }

    public Node buildNode(int value) {
        Node node = nodeMap.get(value);
        if (node == null) {
            node = new Node(value);
            nodeMap.put(value, node);
        }
        return node;
    }

    public Edge buildEdge(int from, int to, int weight) {
        Node fromNode = buildNode(from);
        Node toNode = buildNode(to);
        Map<Node, Edge> nodeEdgeMap = edgeMap.computeIfAbsent(fromNode, k -> new HashMap<>());
        Edge edge = nodeEdgeMap.get(toNode);
        if (edge == null) {
            edge = new Edge(fromNode, toNode, weight);
            nodeEdgeMap.put(toNode, edge);
            edges.add(edge);
            fromNode.out++;
            toNode.in++;
            fromNode.nexts.add(edge);
        } else {
            edge.weight = Math.min(edge.weight, weight);
        }
        return edge;
    }

    public void buildGragh(int[][] times) {
        for (int[] time : times) {
            buildEdge(time[0], time[1], time[2]);
        }
    }
}