图论 · 最短路 · Dijkstra 算法

图论 · 最短路 · Dijkstra 算法

序言

Hello，各位小伙伴们，从今天开始，我们将要进入图论专题的新章节——最短路问题。最短路在算法题里面非常常见，有时候，你甚至发现不了它的身影，但它总是伴随着我们。往往很多题都可以抽象成一个图，进而使用最短路算法进行求解，从这里也可以看出最短路的重要性。话不多说，先来看这个章节的第一讲——Dijkstra 算法。

引入

开始前，先来看一个问题，洛谷P4779：

这道题目要求我们求出从起点 $s$ 到每个点的最短距离，保证从 $s$ 出发可以到达所有点。按照之前所学的内容，我们想到的可能是搜索每条路径，不断记录最小值。但问题是，搜索的效率比较慢，在应对最短路的题目时往往是力不从心，亟需更加优秀的算法来进行求解。于是，我们引出了最短路算法。

Dijkstra 算法介绍

Dijkstra 算法，用于求单源最短路的问题，也就是只有一个起点的最短路。它有两个版本，分别是朴素版的 Dijkstra 和堆优化版的 Dijkstra，二者的适用条件有所不同，详见下表：

算法名称	存储方式	时间复杂度	适用条件
朴素版 Dijkstra	邻接矩阵	$\mathcal{O}(n^2)$	稠密图
堆优化版 Dijkstra	邻接表	$\mathcal{O}(m\log n)$	稀疏图

这里还需要注意的是，如果我们在堆优化版 Dijkstra 里使用手写堆的话，其时间复杂度为 $\mathcal{O}(m\log n)$，但如果使用 STL 模板库中的 priority_queue 的话，其时间复杂度为 $\mathcal{O}(m\log m)$，但总体规模不变 。

Dijkstra 算法思路

Dijkstra 算法基于贪心的思想，在此为了节省篇幅，不做过多的证明，感兴趣的读者可以自行查阅资料。

Dijkstra 算法主要思路由以下几部分组成，我们设定集合 $S$ 里存储的是所有已经确定最短距离的点：

• 初始化

  • 将起点 $s$ 的最短距离设为 $1$；
  • 循环遍历其他点，将其他点的最短距离初始化为 $+\infty$；

• 循环遍历所有点：

  • $t\leftarrow \text{不在}S\text{中的距离最近的点}$；
  • $s\stackrel{\text{加入}}{\leftarrow }t$；
  • 用 $t$ 更新其他点的最短距离。

不难发现，上面的循环一共有两层，一层用于遍历所有点，一层用于遍历寻找点。事实上，我们可以使用堆来维护不在 $S$ 中距离最小的点，这也就是堆优化的 Dijkstra 算法：

• 初始化

  • 将起点 $s$ 的最短距离设为 $1$；
  • 循环遍历其他点，将其他点的最短距离初始化为 $+\infty$；

• 将起点放入堆中；

• 循环直到堆为空：

  • 取出堆顶元素，记录它的两个参数（距离和编号）；
  • 用这个点更新其他店的最短距离。

Dijkstra 算法实现

朴素版 Dijkstra：

void Dijkstra() {
	memset(dis, 0x3f, sizeof dis);
	dis[1] = 0;
	for (int i = 0; i < n; i++) {
		int t = -1;
		for(int j = 1; j <= n; j++)
			if (!vis[j] && (t == -1 || dis[t] > dis[j]))
				t = j;
		vis[t] = true;
		for(int j = 1; j <= n; j++)
			dis[j] = min(dis[j], dis[t] + g[t][j]);
	}
}

堆优化版 Dijkstra：

void add(int a, int b, int c) {
	e[idx] = b;
	w[idx] = c;
	ne[idx] = h[a];
	h[a] = idx ++;
}

void Dijkstra() {
	memset(dis, 0x3f, sizeof dis);
	dis[1] = 0;
	priority_queue<PII, vector<PII>, greater<PII> > heap;
	heap.push({0, 1});
	while (!heap.empty()) {
		auto t = heap.top();
		heap.pop();
		int ver = t.second, distance = t.first;
		if (vis[ver]) continue;
		for (int i = h[ver]; i != -1; i = ne[i]) {
			int j = e[i];
			if (dis[j] > distance + w[i]) {
				dis[j] = distance + w[i];
				heap.push({dis[j], j});
				vis[ver] = true;
			}
		}
	}
}

最后提一嘴，我在这里用到的是链式向前星加边，也可以采用动态数组存边，但由于扩容的瓶颈，其效果没有链式向前星好，但一般算法题不会过分地卡这一点。

本期文章例题参考代码

#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
const int N = 1e6 + 10;
int n, m, s;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];

void add(int a, int b, int c) {
	e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

void 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});
			}
		}
	}
}

int main() {
	scanf("%d%d%d", &n, &m, &s);
	memset(h, -1, sizeof h);
	while (m -- ) {
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);
		add(a, b, c);
	}
	dijkstra();
	for (int i = 1; i <= n; i++) {
		cout << dist[i] << " ";
	}
	return 0;
}