【洛谷 P4779】【模板】单源最短路径（标准版）题解（带权有向图+单源最短路+Dijkstra算法+链式前向星+最小堆）

【模板】单源最短路径（标准版）

题目背景

2018 年 7 月 19 日，某位同学在 NOI Day 1 T1 归程 一题里非常熟练地使用了一个广为人知的算法求最短路。

然后呢？

$100\to 60$；

$\text{Ag}\to \text{Cu}$；

最终，他因此没能与理想的大学达成契约。

小 F 衷心祝愿大家不再重蹈覆辙。

题目描述

给定一个 $n$ 个点，$m$ 条有向边的带非负权图，请你计算从 $s$ 出发，到每个点的距离。

数据保证你能从 $s$ 出发到任意点。

输入格式

第一行为三个正整数 $n,m,s$。
第二行起 $m$ 行，每行三个非负整数 $u_i,v_i,w_i$，表示从 $u_i$ 到 $v_i$ 有一条权值为 $w_i$ 的有向边。

输出格式

输出一行 $n$ 个空格分隔的非负整数，表示 $s$ 到每个点的距离。

样例 #1

样例输入 #1

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

样例输出 #1

0 2 4 3

提示

样例解释请参考 数据随机的模板题。

$1\le n\le 10^5$；

$1\le m\le 2\times 10^5$；

$s=1$；

$1\le u_i,v_i\le n$；

$0\le w_i\le 10^9$,

$0\le \sum w_i\le 10^9$。

本题数据可能会持续更新，但不会重测，望周知。

2018.09.04 数据更新 from @zzq

---

思路

在 dijkstra 函数中，首先初始化 vis 以记录每个节点是否已被访问，然后对 dist 和 prior 进行初始化。如果节点是源节点 s，则 dist 设为 0，并将该节点放入最小堆 hmin；否则，dist 设为 INF，prior 设为 -1。

然后进入主循环，当最小堆 hmin 不为空时，从堆中弹出顶部节点 t，获取其节点编号 u 和到源节点的距离 du。如果节点 u 已被访问，即 vis[u] 为 1，则跳过此次循环。否则，将 vis[u] 设为 1，表示节点 u 已被访问。

接着，遍历节点 u 的所有相邻节点 v。如果通过节点 u 到达节点 v 的距离 du + edge[i].w 小于当前记录的到达 v 的最短距离 dist[v]，则更新 dist[v] 为 du + edge[i].w，并更新 v 的前驱节点 prior[v] 为 u。然后，将节点 v 和其更新后的最短距离 dist[v] 一起放入最小堆 hmin。

这个过程会持续，直到最小堆 hmin 为空，即所有可达的节点都已被访问。此时，数组 dist 中存储的就是从源节点 s 到每个节点的最短距离。

注意

两个点之间可能有多条边。但是由于使用了最小堆进行优化，多条边并不会影响结果的正确性，所以不需要在插入边时检查是否存在多条边连接同一对节点。

当遍历到一条从节点 u 到节点 v 的边，且通过 u 到 v 的距离小于当前记录的到 v 的最短距离时，会更新 dist[v] 并将 v 加入最小堆。如果存在另一条从 u 到 v 的边，其权重更小，那么在后续的遍历过程中，也会将 v 再次加入最小堆，并更新 dist[v]。这样，即使一开始加入堆的是权重较大的边，但由于堆顶总是当前未处理节点中 dist 值最小的节点，所以权重较小的边最终仍会被优先处理。

如果在插入边时检查是否存在多条边连接同一对节点，反而会增加时间复杂度，导致部分测试点报TLE。

---

AC代码

#include <algorithm>
#include <bitset>
#include <cstring>
#include <iostream>
#include <queue>
#define AUTHOR "HEX9CF"
using namespace std;
using ll = long long;

const int N = 1e6 + 7;
const int INF = (1 << 31) - 1;

struct Edge {
	int w, to, next;
} edge[N];
int head[N];
int cnt = 0;

struct Node {
	int v, dist;
	bool operator<(const Node &b) const { return dist > b.dist; }
};

// 点的个数、有向边的个数、出发点的编号
int n, m, s;
// 最短路径长度
int dist[N];
// 前驱节点
int prior[N];
bitset<N> vis;
priority_queue<Node> hmin;

void add(int u, int v, int w) {
	edge[cnt] = {w, v, head[u]};
	head[u] = cnt++;
}

void dijkstra() {
	vis.reset();
	for (int i = 1; i <= n; i++) {
		if (i == s) {
			// 出发点
			dist[i] = 0;
			hmin.push({i, 0});
		} else {
			dist[i] = INF;
			prior[i] = -1;
		}
	}
	while (hmin.size()) {
		auto t = hmin.top();
		hmin.pop();
		int u = t.v;
		int du = t.dist;
		if (vis[u]) {
			// 两个点之间可能有多条边
			continue;
		}
		vis[u] = 1;
		for (int i = head[u]; ~i; i = edge[i].next) {
			int v = edge[i].to;
			if (dist[v] > (du + edge[i].w)) {
				dist[v] = du + edge[i].w;
				prior[v] = u;
				hmin.push({v, dist[v]});
			}
		}
	}
}

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);

	memset(head, -1, sizeof(head));

	cin >> n >> m >> s;
	for (int i = 1; i <= m; i++) {
		int u, v, w;
		cin >> u >> v >> w;
		add(u, v, w);
	}
	dijkstra();
	for (int i = 1; i <= n; i++) {
		cout << dist[i] << " ";
	}
	cout << "\n";
	return 0;
}

---