Description：

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

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

输入：

第一行包含整数n和m。

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

数据范围

1≤n,m≤1.5×10^51≤n,m≤1.5×10 ^5

图中涉及边长均不小于0，且不超过10000。

输出：

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

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

样例输入：

3 3
1 2 2
2 3 1
1 3 4

样例输出：

算法思想：

因为这是一道不存在负权边的单源最短路问题，所以，很显然，要用我们熟悉的Dijkstra算法来做，看到数据范围，m,n都是在10^5量级的。明显我们需要用邻接表来存储，但是，各（zhi）路（shi）精（yuan）神（bo），的出题者给的这数据范围是想要卡掉朴素算法的，所以，堆优化就来了。
这里，我们用小顶堆来存储，所以，就需要这句话：

priority_queue<PII,vector<PII>,greater<PII> > heap;

在函数里，只需要找不在堆里，且到起点距离最短的点来松弛就可以了

时间复杂度：

$O(m*logn)$

代码实现：

#include <bits/stdc++.h>

using namespace std;

typedef pair<int,int> PII;
const int N=1500010, MAXN=0x3f3f3f3f;
int h[N],e[N],ne[N],w[N],idx;
int st[N],dis[N];
priority_queue<PII,vector<PII>,greater<PII> > heap;
int n,m;
void add(int a,int b,int d)
{
    e[idx]=b;
    w[idx]=d;
    ne[idx]=h[a];
    h[a]=idx++;
}
int djstl()
{
    memset(dis,0x3f,sizeof dis);
    dis[1]=0;
    heap.push({0,1});
    while(heap.size())
    {
        PII t=heap.top();
        heap.pop();
        int d=t.first,u=t.second;
        if(st[u])
            continue;
        st[u]=1;
        for(int i=h[u]; i!=-1; i=ne[i])
        {
            int v=e[i];
            if(dis[v]>d+w[i])
            {
                dis[v]=d+w[i];
                heap.push({dis[v],v});
            }
        }
        
    }if(dis[n]==MAXN)
            return -1;
        else
            return dis[n];
}

int main()
{
    memset(h,-1,sizeof h);
    scanf("%d%d",&n,&m);
    for(int i=1; i<=m; i++)
    {
        int a,b,d;
        scanf("%d%d%d",&a,&b,&d);
        add(a,b,d);
    }
    int t=djstl();
    printf("%d\n", t);
    return 0;
}

理解了，就看你自己的造化了

chenchen题解：Dijkstra求最短路堆优化版