给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。
请你求出 11 号点到 n 号点的最短距离，如果无法从 11 号点走到 n 号点，则输出 −1−1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1−1。
数据范围
1≤n,m≤1.5×10^5，
图中涉及边长均不小于 0，且不超过 10000。
数据保证：如果最短路存在，则最短路的长度不超过 10^9。
输入样例：
3 3
1 2 2
2 3 1
1 3 4
输出样例：
3思路：这道题的堆优化我们使用优先队列来做（小根堆），而且因为我们既要存当前点到起点的距离，又要存当前点的编号，所以我们使用一个pair，又因为我们是根据距离来判断入堆的时机的（每次离起点最近的点入堆），所以优先排序的是距离，也就是pair的first元素应该是距离。
typedef pair<int,int> PII;
priority_queue<PII,vector<PII>,greater<PII>> heap; // 数据类型， 容器， 排序方式
//定义一个升序的优先队列（小根堆）
heap.push({0,1}); //放入距离，节点编号，这里1号点到1号点的距离是0
//这个顺序不能倒，pair排序时是先根据first，再根据second，这里显然要根据距离排序
先看完整代码
示例代码：
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int N=1e6+10;
typedef pair<int,int> PII;
int n,m;
int h[N],e[N],ne[N],w[N],idx; //稀疏图用邻接表存，w存边权值
int dist[N]; //1号点到n号点的最短距离
int st[N]; //当前点是否找到了最短距离
void add(int a,int b,int c) //添加一条从a指向b的边
{
e[idx]=b; //算法保证了会选出最短的路，所以不对重边或自环情况做处理，也就是会存在冗余
w[idx]=c;
ne[idx]=h[a];
h[a]=idx;
idx++;
}
int dijkstra() //输出一个整数，表示1号点到n号点的最短距离。
{
memset(dist,0x3f,sizeof(dist));
dist[1]=0;
priority_queue<PII,vector<PII>,greater<PII>> heap; // 数据类型， 容器， 排序方式
//定义一个升序的优先队列（小根堆）
heap.push({0,1}); //放入距离，节点编号，这里1号点到1号点的距离是0
//这个顺序不能倒，pair排序时是先根据first，再根据second，这里显然要根据距离排序
while(heap.size())
{
auto t=heap.top(); //每次找到堆里面最小距离的点，也就是不在集合S中距离最短的点
heap.pop();
int ver=t.second,distance=t.first; //ver是节点编号，distance是点的距离
if(st[ver]) continue; //如果ver这个点之前出来过，说明当前这个点是冗余（重边自环之类的），也就没有必要继续处理，直接continue，不再执行下面的语句，而是执行下一次的while循环
/*
堆优化版的是将距离直接加入到堆中.
例如:dist[5]=9(在堆中{9,5},第一次更新时加入),dist[5]=7(在堆中{7，5},第二次更新时加入)
使用时用的是dist[5]=7,将该点({7,5})弹出后,在下一次循环中,如果{9,5}在堆顶的话,使用时
两者间肯定要选距离要小的那个,不能使用{9,5}重复更新,所以要用st数组进行标记
*/
st[ver]=true; //如果这个点之前没有出来过，就标记找到了这个点的最短距离
for(int i=h[ver];i!=-1;i=ne[i]) //每次都取这个距离最小的点来更新其他点，i是当前点ver指向的点的下标（与当前点与连线的点）
{
//更新ver指向的节点距离
//每次只更新最小点的邻接边不是整个图
int j=e[i]; //这里j是下标i对应的节点编号（i存的是下标，下标对应的点的值就是结点编号）
if(dist[j]>dist[ver]+w[i]) //如果1到j的最短距离比1到ver的最短距离加上ver到j的距离大
{
dist[j]=dist[ver]+w[i]; //那么就更新1到j的最短距离，再把这个新的最短距离加入堆中
heap.push({dist[j],j});
}
}
}
if(dist[n]==0x3f3f3f3f)
{
return -1;
}
return dist[n];
}
int main()
{
ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
memset(h,-1,sizeof(h));
cin>>n>>m;
while(m--)
{
int a,b,c;
cin>>a>>b>>c;
add(a,b,c);
}
cout<<dijkstra()<<endl;
return 0;
}
//一个点到另一个点的距离有10，后来又加了15或者其他的更大距离，但是因为是小根堆，所以最短距离肯定会出现在最前面
//所以除了在堆顶的元素，底下那些元素都算是冗余备份元素，可以舍弃掉了，直接continue就行。
代码基本都比较好理解，注意这道题用邻接表存，其中e[ ]存的就是节点编号
for(int i=h[ver];i!=-1;i=ne[i]) //每次都取这个距离最小的点来更新其他点，i是当前点ver指向的点的下标（与当前点与连线的点）
{
//更新ver指向的节点距离
//每次只更新最小点的邻接边不是整个图
int j=e[i]; //这里j是下标i对应的节点编号（i存的是下标，下标对应的点的值就是结点编号）
if(dist[j]>dist[ver]+w[i]) //如果1到j的最短距离比1到ver的最短距离加上ver到j的距离大
{
dist[j]=dist[ver]+w[i]; //那么就更新1到j的最短距离，再把这个新的最短距离加入堆中
heap.push({dist[j],j});
}
}关于w[i]和i，j在这里面都代表什么：
while(heap.size())
{
auto t=heap.top(); //每次找到堆里面最小距离的点，也就是不在集合S中距离最短的点
heap.pop();
int ver=t.second,distance=t.first; //ver是节点编号，distance是点的距离
if(st[ver]) continue; //如果ver这个点之前出来过，说明当前这个点是冗余（重边自环之类的），也就没有必要继续处理，直接continue，不再执行下面的语句，而是执行下一次的while循环
/*
堆优化版的是将距离直接加入到堆中.
例如:dist[5]=9(在堆中{9,5},第一次更新时加入),dist[5]=7(在堆中{7，5},第二次更新时加入)
使用时用的是dist[5]=7,将该点({7,5})弹出后,在下一次循环中,如果{9,5}在堆顶的话,使用时
两者间肯定要选距离要小的那个,不能使用{9,5}重复更新,所以要用st数组进行标记
*/
st[ver]=true; //如果这个点之前没有出来过，就标记找到了这个点的最短距离
for(int i=h[ver];i!=-1;i=ne[i]) //每次都取这个距离最小的点来更新其他点，i是当前点ver指向的点的下标（与当前点与连线的点）
{
//更新ver指向的节点距离
//每次只更新最小点的邻接边不是整个图
int j=e[i]; //这里j是下标i对应的节点编号（i存的是下标，下标对应的点的值就是结点编号）
if(dist[j]>dist[ver]+w[i]) //如果1到j的最短距离比1到ver的最短距离加上ver到j的距离大
{
dist[j]=dist[ver]+w[i]; //那么就更新1到j的最短距离，再把这个新的最短距离加入堆中
heap.push({dist[j],j});
}
}
}为什么要有continue和冗余？
代码中的for循环会把所有满足dist[j] > distance + w[i]的点都加进去，有的点它既是a的邻接点又是b的邻接点，这样的点可能会在将a的邻接点更新的时候加进去一次，又在更新b的邻接点的时候又加进去一次，这样队列中就有两个一样的点，虽然距离不同，此时这两个一样的点拓展的点也是一样的，所以我们取距离短的就好。
最后：
连线很多的时候，对应的就是稠密图，显然易见，稠密图的路径太多了，所以就用点来找，也就是抓重点；
点很多，但是连线不是很多的时候，对应的就是稀疏图，稀疏图的路径不多，所以按照连接路径找最短路，这个过程运用优先队列，能确保每一次查找保留到更新到队列里的都是最小的，同时还解决了两个点多条路选择最短路的问题；
参考：AcWing 850. Dijkstra求最短路 II - AcWing
