堆优化dijkstra

 在介绍堆优化的dijkstra算法之前，先介绍一种存储图的数据结构——链式前向星：

链式前向星其实就是静态建立的邻接表，时间效率为O（m），空间效率也为O（m）。遍历效率也为O（m）。

struct Edge{
    int to, w, next;//终点，边权，同起点的上一条边的编号
}edge[maxn];//边集
int head[maxn];//head[i],表示以i为起点的第一条边在边集数组的位置（编号）
void init(){//初始化
    for (int i = 0; i <= n; i++) head[i] = -1;
    cnt = 0;
}

• 链式前向星存的是以【1，n】为起点的边的集合
• Next，表示与这个边起点相同的上一条边的编号。
• head[ i ]数组，表示以 i 为起点的最后一条边的编号。
• head数组一般初始化为-1,遍历时以edge[ j ].next为 -1做为终止条件。

遍历函数是这样的：

for(int i = 1; i <= n; i++)//n个起点
    {
        cout << i << endl;
        for(int j = head[i]; j != -1; j = edge[j].next)//遍历以i为起点的边
        {
            cout << i << " " << edge[j].to << " " << edge[j].w << endl;
        }
        cout << endl;
    }

第一层for循环是找每一个点，依次遍历以【1，n】为起点的边的集合。第二层for循环是遍历以 i 为起点的所有边，k首先等于head[ i ]，注意head[ i ]中存的是以 i 为起点的最后一条边的编号。然后通过edge[ j ].next来找下一条边的编号。我们初始化head为-1，所以找到你最后一个边（也就是以 i 为起点的第一条边）时，以edge[ j ].next为 -1做为终止条件。

dijkstra算法：

1. 初始时， S只包含起点s；U包含除s之外的其他顶点，且U中顶点的距离为“起点s到该顶点的距离”【例如：U中顶点v的距离为(s, v)的长度，然后s和v不相邻，则v的距离为∞】。
2. 从U中选出“距离最短的顶点k”，并将顶点k加入到S中；同时，从U中移除顶点k。
3. 更新U中各个顶点到起点s的距离。之所以更新U中顶点的距离，是由于上一步中确定了k是求出最短路径的顶点，从而可以利用k来更新其他顶点的距离；例如，(s, v)的距离可能大于(s, k)+(k, v)的距离。
4. 重复步骤2和3，直到遍历完所有顶点。

在这里可以发现第2步要选出“距离最短的顶点k”，这里如果用最小堆优化，时间复杂度会降低很多，如果采用邻接矩阵存储边，每次遍历边还是会使时间复杂度居高不下，而邻接表不好写但效率好，所以这里用链式向前星存储边。用最小堆优化后时间复杂度为O((n+m)logn)，这里发现在稠密图中接近n^2，所以不必用堆优化。

所以dijkstra算法适用于稀疏图。

下面附上一道洛谷原题：CF20C Dijkstra?

给出一张图，请输出其中任意一条可行的从点 1到点 n的最短路径。

输入输出格式

输入格式

第一行：两个整数n，m，分别表示点数和边数

接下来m行：每行三个整数u，v，w，表示u和v之间连一条边权为w的双向边。

输出格式

一行：一个可行的路径，如果不存在这种路径输出-1

2<=n<=10^5，0<=m<=10^5

输入输出样例

输入 

5 6
1 2 2
2 5 5
2 3 4
1 4 1
4 3 3
3 5 1

输出 

1 4 3 5 

 不多说了，直接上代码

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cstring>
using namespace std;
typedef long long LL;
const int N = 2e5 + 5;
int n, m;
struct edge { int to, nxt, val; } e[N];
int cnt, head[N];
void add(int from, int to, int val) {
	e[++ cnt].to = to;
	e[cnt].val = val;
	e[cnt].nxt = head[from];
	head[from] = cnt;
}
int dis[N], vis[N], pre[N];
LL ans[N];
void spfa() {
	for(int i = 1;i <= n;i ++) dis[i] = 1e15;
	queue <int> q; q.push(1);
	dis[1] = 0; vis[1] = 1;
	while(! q.empty()) {
		int tp = q.front(); q.pop();
		vis[tp] = 0;
		for(int i = head[tp]; i ;i = e[i].nxt) {
			int to = e[i].to, val = e[i].val;
			if(dis[to] > dis[tp] + val) {
				dis[to] = dis[tp] + val;
				pre[to] = tp;
				if(! vis[to]) q.push(to), vis[to] = 1;
			}
		}
	}
}
signed main() {
	cin >> n >> m;
	for(int i = 1, a, b, l;i <= m;i ++) {
		cin >> a >> b >> l;
		add(a, b, l); add(b, a, l);
	}
	spfa();
	if(dis[n] == 1e15) { cout << "-1"; return 0; }
	int t = n, tot = 0;
	while(t != 1) {
		ans[++ tot] = t;
		t = pre[t];
	}
	ans[++ tot] = 1;
	for(int i = tot; i ;i --) cout << ans[i] << " ";
	return 0;
}