图论 · 最短路 · Dijkstra 算法
序言
Hello,各位小伙伴们,从今天开始,我们将要进入图论专题的新章节——最短路问题。最短路在算法题里面非常常见,有时候,你甚至发现不了它的身影,但它总是伴随着我们。往往很多题都可以抽象成一个图,进而使用最短路算法进行求解,从这里也可以看出最短路的重要性。话不多说,先来看这个章节的第一讲——Dijkstra 算法。
引入
开始前,先来看一个问题,洛谷P4779:
这道题目要求我们求出从起点
s
s
s 到每个点的最短距离,保证从
s
s
s 出发可以到达所有点。按照之前所学的内容,我们想到的可能是搜索每条路径,不断记录最小值。但问题是,搜索的效率比较慢,在应对最短路的题目时往往是力不从心,亟需更加优秀的算法来进行求解。于是,我们引出了最短路算法。
Dijkstra 算法介绍
Dijkstra 算法,用于求单源最短路的问题,也就是只有一个起点的最短路。它有两个版本,分别是朴素版的 Dijkstra 和堆优化版的 Dijkstra,二者的适用条件有所不同,详见下表:
算法名称 | 存储方式 | 时间复杂度 | 适用条件 |
---|---|---|---|
朴素版 Dijkstra | 邻接矩阵 | O ( n 2 ) \mathcal{O}(n^2) O(n2) | 稠密图 |
堆优化版 Dijkstra | 邻接表 | O ( m log n ) \mathcal{O}(m \log n) O(mlogn) | 稀疏图 |
这里还需要注意的是,如果我们在堆优化版 Dijkstra 里使用手写堆的话,其时间复杂度为
O
(
m
log
n
)
\mathcal{O}(m \log n)
O(mlogn),但如果使用 STL 模板库中的 priority_queue
的话,其时间复杂度为
O
(
m
log
m
)
\mathcal{O}(m \log m)
O(mlogm),但总体规模不变 。
Dijkstra 算法思路
Dijkstra 算法基于贪心的思想,在此为了节省篇幅,不做过多的证明,感兴趣的读者可以自行查阅资料。
Dijkstra 算法主要思路由以下几部分组成,我们设定集合 S S S 里存储的是所有已经确定最短距离的点:
-
初始化
- 将起点 s s s 的最短距离设为 1 1 1;
- 循环遍历其他点,将其他点的最短距离初始化为 + ∞ +\infin +∞;
-
循环遍历所有点:
- t ← 不在 S 中的距离最近的点 t \leftarrow \text{不在} \ S\ \text{中的距离最近的点} t←不在 S 中的距离最近的点;
- s ← 加入 t s \xleftarrow{\text{加入}} t s加入t;
- 用 t t t 更新其他点的最短距离。
不难发现,上面的循环一共有两层,一层用于遍历所有点,一层用于遍历寻找点。事实上,我们可以使用堆来维护不在 S S S 中距离最小的点,这也就是堆优化的 Dijkstra 算法:
-
初始化
- 将起点 s s s 的最短距离设为 1 1 1;
- 循环遍历其他点,将其他点的最短距离初始化为 + ∞ +\infin +∞;
-
将起点放入堆中;
-
循环直到堆为空:
- 取出堆顶元素,记录它的两个参数(距离和编号);
- 用这个点更新其他店的最短距离。
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;
}