Dijkstra堆优化（链式前向星存图）

失踪人口回归系列
实在太懒了一直拖拖拖…

了解Dijkstra的都知道一般的Dijkstra通过不断寻找已遍历的点集合可以到达的最短边来求单元最短路径,如果能优化寻找最短边的过程那么就可以实现优化了。优先队列就是一个不错的选择，而优先队列的原理就是堆排序。
下面是模板代码：

#include<iostream>
#include<queue>
using namespace std;
#define INF 0x3f3f3f3f
const int maxn = 1e3 + 7;
struct edge {
	int to;
	int w;
	int next;
}e[maxn * 2 + 5];//一般来说无向图的最大边数是n*(n-1)
struct temp {//用来临时存边
	int dis;
	int node;
	bool operator<(const temp &a)const {
	//优先队列默认是大顶堆，所以要重载比较运算符
		return dis > a.dis;
	}
};
int head[maxn];
int dis[maxn];
bool set[maxn];
int cnt;
void init(int n) {//初始化
	cnt = 0;
	for (int i = 0; i <= n; i++) head[i] = -1, dis[i] = INF, set[i] = 0;
}
void addEdge(int from, int to, int w) {
	e[cnt].to = to;
	e[cnt].w = w;
	e[cnt].next = head[from];
	head[from] = cnt++;
}
void HeapDijkstra(int s) {
	priority_queue<temp> pq;
	dis[s] = 0;//自己到自己当然距离是0
	pq.push({ dis[s],s });
	while (!pq.empty()) {
		temp t = pq.top();//堆顶的一定是要寻找的最短边
		pq.pop();
		if (set[t.node]) continue;
		set[t.node] = 1;//加入点集
		for (int i = head[t.node]; i != -1; i = e[i].next) {//更新最短路径
			int v = e[i].to;
			if (!set[v] && dis[t.node] + e[i].w < dis[v]) {
				dis[v] = dis[t.node] + e[i].w;
				pq.push({ dis[v],v });
			}
		}
	}
}
int main() {
	int n, m;
	int x, y, w;
	cout<<"输入点的数目和边的数目：";
	cin >> n >> m;
	init(n);
	for (int i = 0; i < m; i++) {
		cin >> x >> y >> w;//无向图
		addEdge(x, y, w);
		addEdge(y, x, w);
	}
	int s;
	cout<<"输入源点：";
	cin >> s;
	HeapDijkstra(s);
	for (int i = 1; i <= n; i++) {
		printf("从%2d到%2d的最短距离是：%-4d\n", s, i, dis[i]);
	}
	return 0;
}

一般来说堆优化过后的Dijkstra就可以用来寻找1e5数量级别（mlg n）的单源最短路径了，而且代码量也没有增加，边多点少的图使用朴素的Dijkstra而点多边较少的则可以使用堆优化后的Dijkstra算法~