图论--单源最短路-稀疏图 Dijkstra求最短路 II

给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。

请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。

输入格式
第一行包含整数 n 和 m。

接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。

输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。

如果路径不存在，则输出 −1。

数据范围
1≤n,m≤1.5×105,
图中涉及边长均不小于 0，且不超过 10000。
数据保证：如果最短路存在，则最短路的长度不超过 109。

输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3
https://www.acwing.com/problem/content/852/

sort 和优先队列 默认顺序（升序降序：java同c++）
默认优先级只对不加comparator或者比较函数的情况适用，加了比较函数，那么排序就完全按照比较函数来确定，这时候同一个比较函数对sort和优先队列是一样的顺序。就记住一句话：（返回负数就是o1(a)在前）
参考：https://blog.csdn.net/qq_43868654/article/details/115053059

import java.util.*;

public class Main
{
	static int N=150005,M=N,n,m,idx;
	static int h[]=new int[N],e[]=new int[M],ne[]=new int[M],w[]=new int[M];
	static boolean st[]=new boolean[N];
	static int dist[]=new int [N];
	
	static void add(int a,int b,int c)
	{
		e[idx]=b;ne[idx]=h[a];w[idx]=c;h[a]=idx++;
	}
	static class pair
	{
		int id,w;
		public pair(int a,int b)
		{
			id=a;w=b;
		}
	}
	static class mcomp implements Comparator<pair>
	{
		public int compare(pair o1, pair o2) {
			return o1.w-o2.w;
		}
	}//这个对Sort是从小到大排序，对优先队列也是从小到大排序
	static int dijkstra(int u)
	{
		Arrays.setAll(dist, x->0x3f3f3f3f);
		dist[u]=0;
		PriorityQueue<pair> q=new PriorityQueue<pair>(new mcomp());
		q.offer(new pair(u,0));
		
		while(!q.isEmpty())
		{
			pair t=q.poll();
			//if(st[t.id])continue;//这两条可加可不加，效率差不多
			//st[t.id]=true;
			for(int i=h[t.id];i!=-1;i=ne[i])
			{
				int j=e[i];
				if(dist[j]>dist[t.id]+w[i])
				{
					dist[j]=dist[t.id]+w[i];//dist[t.id]等价于t.w;
					q.offer(new pair(j,dist[j]));
				}
			}
		}
		if(dist[n]==0x3f3f3f3f)return -1;
		else return dist[n];
	}
	
	
	public static void main(String args[])
	{
		Scanner sc=new Scanner(System.in);
		n=sc.nextInt();
		m=sc.nextInt();
		
		Arrays.setAll(h, x->-1);
		for(int i=0;i<m;++i)
		{
			int a,b,c;
			a=sc.nextInt();
			b=sc.nextInt();
			c=sc.nextInt();
			add(a,b,c);
		}
		int ans=dijkstra(1);
		System.out.println(ans);
	}
}