Dijkstra堆优化

Dijkstra是一个非常不错的最短路算法，它使用两层循环进行枚举，通过每次更新蓝白点的方式更新最短路，时间复杂度为O（n^2），优于floyd的O（n^3），不过只能用于计算单源最短路，而且无法处理负权边。

今天我们尝试用堆来优化它。这里我们使用了STL中的set和pair。set本身相当于一个小根堆，内部自动从小到大排序。（据说内部使用平衡树实现？蒟蒻瑟瑟发抖。）操作方式大致就是insert（插入）和erase（删除），不过他会把相同的数据融合到一起，如果不想这样可以使用multiset。对于堆的遍历我们不能像数组一样直接遍历，而是要使用迭代器。（用法下面代码有）而pair相当于一个有两个成员的且已经重定义的struct，使用makepair来新构造一个pair。

具体怎么做呢？我们从起点出发，然后枚举每一条能走到的边（这里使用了邻接表存图），之后在选取最短的一条边时，我们使用堆即可，也就是将贪心变成了堆，这样时间复杂度就变为了O(nlogn)。

直接上代码看一下就好啦！

#include<cstdio>
#include<vector>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<set>
#include<map>
#include<queue>
#define mp make_pair
#define fi first
#define sc second
#define faker(i,a,n) for(int i = a;i <= n;i++)
#define duke(i,n,a) for(int i = n;i >= a;i--)
const int M = 100001;
int v[M],num,next[M],head[M],cost[M],dis[M];
bool vis[M];
int n,m,x,y,z;
using namespace std;
typedef pair<int,int> pr;//pair等于有两个成员且已经重定义的struct
void add(int x,int y,int z)//邻接表存图
{
    v[++num] = y;
    next[num] = head[x];
    cost[num] = z;
    head[x] = num;
}
int read()
{
    int num = 0;
    char ch,last = ' ';
    ch = getchar();
    while(ch < '0' || ch > '9')
    {
        if(ch == '-') last = ch;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9')
    {
        ans *= 10;
        ans += ch - '0';
        ch = getchar();
    }
    if(last == '-') ans = -ans;
    return ans; 
}
set<pr> q;//定义一个堆
set<pr> :: iterator it;//迭代器定义
int main()
{
    n = read(),m = read();
    faker(i,1,m)//循环（不要问我为什么有这么奇怪的名字）
    {
        x = read(),y = read(),z = read();
        add(x,y,z);
    }
    faker(i,1,n) dis[i] = 1000000000;
    dis[1] = 0;
    q.insert(mp(dis[1],1));//将起点压入堆
    faker(i,1,n) vis[i] = 0;
    while(!q.empty())
    {
        pr u = *(q.begin());
        q.erase(q.begin());//删除堆顶元素
        vis[u.sc] = 1;//设置为走过
        for(int i = head[u.sc];i;i = next[i])
        {
            if(dis[v[i]] > dis[u.sc] + cost[i])
            {
                it = q.find(mp(dis[v[i]],v[i]));
                if(it != q.end())q.erase(it);//将当前较长的路径删除
                dis[v[i]] = dis[u.sc] + cost[i];//更新距离
                q.insert(mp(dis[v[i]],v[i]));//更新 ，压入更短的路径
            }
        }
    }
    return 0;
}