堆优化版的Dijkstra（适用于稀疏图）

 上一篇：朴素版Dijkstra

朴素版Dijkstra的实现步骤：

注：S[ ]：当前已确定最短距离的点。

1.初始化距离，使源点到自身点的距离为0，到其他点的距离为无穷大，dis[ 1 ]=0，dis[ i ]=+∞。

2.用for循环循环n次，找到不在S中的距离最短的点t，然后加入S，用t更新其他点的距离。距离更新：对于与顶点u相邻的所有顶点v，如果通过顶点u到达顶点v的距离更短，即d[u]+w(u,v)<d(v)，其中w(u,v)是边的权重，则更新顶点的距离d[v]=d[u]+w(u,v)。

堆优化版的Dijkstra：

与朴素版Dijkstra大致相同，只是在寻找距离最短的点时采用堆的方式寻找，使得每次寻找距离最短的点的时间复杂度变为O（1），循环n 次，总共进行n 次查找，所以总的寻找距离最短的点的时间复杂度为O（n），降低了时间复杂度。（朴素版Dijkstra寻找距离最短的点采用了两个循环其时间复杂度为O（n^2）），此外在实现距离更新时的时间复杂度是m（m是边的数量），所以整个堆优化版的Dijkstra的时间复杂度是mlogn.

堆的实现：

1.采用手写堆：可以保证堆中的元素一直为n

2.c++中可以采用优先队列

例题：

给定一个 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

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;

typedef pair<int,int >PII;//pair类型存储点的编号和距离

const int N = 1e6+10;
int h[N],w[N],ne[N],e[N],idx;//稀疏图采用邻接矩阵存储
bool st[N];
int dist[N];
int n,m;

void add(int x,int y,int z){
    e[idx]=y;
    w[idx]=z;
    ne[idx]=h[x];
    h[x]=idx++;
}

int dijkstra(){
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    priority_queue<PII,vector<PII>,greater<PII>>heap;
    heap.push({0,1});//
    
    while(heap.size()){
        auto t=heap.top();//找到距离最小的点
        heap.pop();
        
        int ver=t.second,distance=t.first;
        
        if(st[ver])continue;
        st[ver]=true;
        for(int i=h[ver];i!=-1;i=ne[i]){
            int j=e[i];
            if(dist[j]>dist[ver]+w[i]){
                dist[j]=dist[ver]+w[i];
                heap.push({dist[j],j});
            }
        }
    }
    if(dist[n]==0x3f3f3f3f)return -1;
    return dist[n];
}

int main(){
    memset(h,-1,sizeof h);
    scanf("%d%d",&n,&m);
    while(m--){
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
    }
    printf("%d",dijkstra());
    return 0;
}