有 N 个网络节点,标记为 1 到 N。
给定一个列表 times,表示信号经过有向边的传递时间。 times[i] = (u, v, w),其中 u 是源节点,v 是目标节点, w 是一个信号从源节点传递到目标节点的时间。
现在,我们向当前的节点 K 发送了一个信号。需要多久才能使所有节点都收到信号?如果不能使所有节点收到信号,返回 -1。
注意:
N 的范围在 [1, 100] 之间。
K 的范围在 [1, N] 之间。
times 的长度在 [1, 6000] 之间。
所有的边 times[i] = (u, v, w) 都有 1 <= u, v <= N 且 0 <= w <= 100。
来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/network-delay-time
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
Dijkstra算法实现
class Solution {
//自己实现的Map
class MyMap{
int[] arr;
MyMap(int size){
arr=new int[size];
for(int i=0;i<size;i++)
arr[i]=-1;
}
void put(int key,int value){
arr[key]=value;
}
int get(int key){
return arr[key];
}
boolean containsKey(int key){
return arr[key]!=-1;
}
void remove(int key){
arr[key]=-1;
}
}
//索引最小堆
class MinHeap {
Edge[] heap;
int size;
MyMap map;
public MinHeap(int size) {
heap=new Edge[size+1];
this.size=0;
map=new MyMap(size+1);
}
private void swap(int p1,int p2) {
Edge t=heap[p1];
heap[p1]=heap[p2];
heap[p2]=t;
}
private void sink(int pos) {
while(2*pos<=size){
int j=2*pos;
if(j<size&&heap[j].weight>heap[j+1].weight)
j++;
if(heap[pos].weight>heap[j].weight)
break;
swap(pos,j);
pos=j;
}
map.put(heap[pos].end,pos);
}
private void swim(int pos) {
while(pos>1&&heap[pos/2].weight>heap[pos].weight){
swap(pos/2,pos);
pos=pos/2;
}
map.put(heap[pos].end,pos);
}
public void add(int end,int weight) {
heap[++size]=new Edge(end,weight);
swim(size);
}
public Edge delMin() {
Edge t=heap[1];
swap(1,size--);
map.remove(t.end);
sink(1);
return t;
}
public void change(int vertex,int weight) {
int pos=map.get(vertex);
heap[pos].weight=weight;
swim(pos);
}
public boolean isEmpty() {
return size==0;
}
}
class Edge {
int end;
int weight;
public Edge(int e,int w) {
this.end=e;
this.weight=w;
}
}
public class Graph {
public ArrayList<Edge>[] adj;
private int v;
private int e;
public Graph(int v) {
adj=new ArrayList[v];
for(int i=0;i<v;i++)
adj[i]=new ArrayList<Edge>();
this.v=v;
}
public void addEdge(int v1,int v2,int w) {
e++;
adj[v1].add(new Edge(v2,w));
}
}
private Graph build(int[][] times,int N){
Graph graph=new Graph(N+1);
for(int[] temp:times)
graph.addEdge(temp[0],temp[1],temp[2]);
return graph;
}
class Dijkstra{
int start;
int[] distTo;
ArrayList<Edge>[] adj;
MinHeap heap;
public Dijkstra(int V,Graph graph,int start) {
distTo=new int[V+1];
for(int i=1;i<=V;i++)
distTo[i]=Integer.MAX_VALUE;
this.adj=graph.adj;
this.start=start;
heap=new MinHeap(V);
distTo[start]=0;
heap.add(start,0);
while(!heap.isEmpty()) {
int v=heap.delMin().end;
relax(v);
}
}
private void relax(int v) {
for(Edge e:adj[v]) {
int w=e.end;
if(distTo[w]>distTo[v]+e.weight) {
distTo[w]=distTo[v]+e.weight;
if(heap.map.containsKey(w))
heap.change(w, distTo[w]);
else
heap.add(w,distTo[w]);
}
}
}
}
public int networkDelayTime(int[][] times, int N, int K) {
Dijkstra d=new Dijkstra(N,build(times,N),K);
int res=0;
for(int i=1;i<d.distTo.length;i++){
if(d.distTo[i]!=Integer.MAX_VALUE)
res=Math.max(res,d.distTo[i]);
else
return -1;
}
return res;
}
}