[蓝桥杯 2022 国 B] 出差

题目描述

$\mathrm{A}$ 国有 $N$ 个城市，编号为 $1\dots N$ 小明是编号为 $1$ 的城市中一家公司的员工，今天突然接到了上级通知需要去编号为 $N$ 的城市出差。

由于疫情原因，很多直达的交通方式暂时关闭，小明无法乘坐飞机直接从城市 $1$ 到达城市 $N$，需要通过其他城市进行陆路交通中转。小明通过交通信息网，查询到了 $M$ 条城市之间仍然还开通的路线信息以及每一条路线需要花费的时间。

同样由于疫情原因，小明到达一个城市后需要隔离观察一段时间才能离开该城市前往其他城市。通过网络，小明也查询到了各个城市的隔离信息。（由于小明之前在城市 $1$，因此可以直接离开城市 $1$，不需要隔离）

由于上级要求，小明希望能够尽快赶到城市 $\mathrm{N}$, 因此他求助于你，希望你能帮他规划一条路线，能够在最短时间内到达城市 $N$ 。

输入格式

第 $1$ 行：两个正整数 $N,M$ 表示 A 国的城市数量, $M$ 表示末关闭的路线数量。

第 $2$ 行: $N$ 个正整数，第 $i$ 个整数 $C_i$ 表示到达编号为 $\mathrm{i}$ 的城市后需要隔离的时间。

第 $3\dots M+2$ 行: 每行 $3$ 个正整数, $u,v,c$, 表示有一条城市 $u$ 到城市 $v$ 的双向路线仍然开通着，通过该路线的时间为 $c$。

输出格式

第 $1$ 行：$1$ 个正整数，表示小明从城市 $1$ 出发到达城市 $N$ 的最短时间。（到达城市 $N$，不需要计算城市 $N$ 的隔离时间）

样例 #1

样例输入 #1

4 4
5 7 3 4
1 2 4
1 3 5
2 4 3
3 4 5

样例输出 #1

13

提示

【样例说明】

【评测用例规模与约定】

对于 $100\%$ 的数据, $1\le N\le 1000,1\le M\le 10000,1\le C_i\le 200,1\le u,v\le$ $N,1\le c\le 1000$

蓝桥杯 2022 国赛 B 组 E 题。

---

思路

首先从输入中读取城市数量 n 和开放的路线数量 m。然后读取每个城市的隔离时间，存储在数组 c 中。接着读取 m 条边的信息，每条边包含起始城市 u，目标城市 v，以及通过该路线需要的时间 w。对于每条边，都将其添加到链式前向星中，同时将该城市的隔离时间加到边的权重上。这样做的目的是在计算从城市 u 到城市 v 的时间时，同时考虑了在城市 v 的隔离时间。

通过 Dijkstra 算法来找到从城市 1 到城市 n 的最短路径。使用 vis.reset() 初始化所有节点为未访问状态。然后，对于每个节点，如果节点是源点（城市 1），则其到自己的最短距离 dist[i] 为 0，并将其加入优先队列 hmin 中。否则，将其最短距离设置为无穷大，并将其前驱节点 prior[i] 设置为 -1，表示还没有找到到达它的最短路径。

然后进入主循环，当优先队列不为空时，取出队列顶部的节点 t，其中 t.v 是节点编号，t.d 是从源点到该节点的当前最短距离。如果该节点已经被访问过，则跳过。否则，将其标记为已访问。然后，遍历从节点 u 出发的所有边，如果通过当前边到达节点 v 的距离 du + edge[i].w 小于 v 的当前最短距离 dist[v]，则更新 dist[v]，并将 v 加入优先队列。

这个过程会持续，直到优先队列为空，或者找到目标节点 n。注意，dist[v] 中的值是从源点到达 v 并在 v 进行隔离的总时间，所以在最后的结果中需要减去城市 n 的隔离时间。

注意

1. 到达一个城市后需要隔离观察一段时间才能离开该城市前往其他城市，将终点城市的隔离时间加到边的权重上即可。
2. 到达城市 n 后不需要隔离，所以在最后的结果中需要减去城市 n 的隔离时间。

---

AC代码

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

const int N = 1e6 + 7;
const int INF = 0x3f3f3f3f;
const ll MOD = 1e9 + 7;

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

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

int n, m;
int c[N];

// 最短路径长度
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 == 1) {
			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.d;
		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;
	for (int i = 1; i <= n; i++) {
		cin >> c[i];
	}
	for (int i = 1; i <= m; i++) {
		int u, v, w;
		cin >> u >> v >> w;
		// 到达一个城市后需要隔离观察一段时间才能离开该城市前往其他城市
		add(u, v, w + c[v]);
		add(v, u, w + c[u]);
	}
	dijkstra();
	// 到达n城后不需要隔离
	cout << dist[n] - c[n] << "\n";
	return 0;
}