蓝桥杯备赛 | 洛谷做题打卡day33

• 【模板】k 短路 / [SDOI2010] 魔法猪学院

  题目背景

  注：对于 $k$ 短路问题，A* 算法的最坏时间复杂度是 $O(nk\log n)$ 的。虽然 A* 算法可以通过本题原版数据，但可以构造数据，使得 A* 算法在原题的数据范围内无法通过。事实上，存在使用可持久化可并堆的算法可以做到在 $O((n+m)\log n+k\log k)$ 的时间复杂度解决 $k$ 短路问题。详情见 OI-Wiki。

  题目描述

  iPig 在假期来到了传说中的魔法猪学院，开始为期两个月的魔法猪训练。经过了一周理论知识和一周基本魔法的学习之后，iPig 对猪世界的世界本原有了很多的了解：众所周知，世界是由元素构成的；元素与元素之间可以互相转换；能量守恒$\dots$。

  iPig 今天就在进行一个麻烦的测验。iPig 在之前的学习中已经知道了很多种元素，并学会了可以转化这些元素的魔法，每种魔法需要消耗 iPig 一定的能量。作为 PKU 的顶尖学猪，让 iPig 用最少的能量完成从一种元素转换到另一种元素$\dots$等等，iPig 的魔法导猪可没这么笨！这一次，他给 iPig 带来了很多 $1$ 号元素的样本，要求 iPig 使用学习过的魔法将它们一个个转化为 $N$ 号元素，为了增加难度，要求每份样本的转换过程都不相同。这个看似困难的任务实际上对 iPig 并没有挑战性，因为，他有坚实的后盾$\dots$现在的你呀！

  注意，两个元素之间的转化可能有多种魔法，转化是单向的。转化的过程中，可以转化到一个元素（包括开始元素）多次，但是一但转化到目标元素，则一份样本的转化过程结束。iPig 的总能量是有限的，所以最多能够转换的样本数一定是一个有限数。具体请参看样例。

  输入格式

  第一行三个数 $N,M,E$，表示 iPig 知道的元素个数（元素从 $1$ 到 $N$ 编号），iPig 已经学会的魔法个数和 iPig 的总能量。

  后跟 $M$ 行每行三个数 $s_i,t_i,e_i$ 表示 iPig 知道一种魔法，消耗 $e_i$ 的能量将元素 $s_i$ 变换到元素 $t_i$。

  输出格式

  一行一个数，表示最多可以完成的方式数。输入数据保证至少可以完成一种方式。

  样例 #1

  样例输入 #1

  4 6 14.9
  1 2 1.5
  2 1 1.5
  1 3 3
  2 3 1.5
  3 4 1.5
  1 4 1.5
  

  样例输出 #1

  3
  

提示

有意义的转换方式共 $4$ 种：

$1\to 4$，消耗能量 $1.5$。

$1\to 2\to 1\to 4$，消耗能量 $4.5$。

$1\to 3\to 4$，消耗能量 $4.5$。

$1\to 2\to 3\to 4$，消耗能量 $4.5$。

显然最多只能完成其中的 $3$ 种转换方式（选第一种方式，后三种方式仍选两个），即最多可以转换 $3$ 份样本。

如果将 $E=14.9$ 改为 $E=15$，则可以完成以上全部方式，答案变为 $4$。

数据规模

占总分不小于 $10\%$ 的数据满足 $N\le 6,M\le 15$。

占总分不小于 $20\%$ 的数据满足 $N\le 100,M\le 300,E\le 100$ 且 $E$ 和所有的 $e_i$ 均为整数（可以直接作为整型数字读入）。

所有数据满足 $2\le N\le 5000$，$1\le M\le 200000$，$1\le E\le 10^7$，$1\le ei\le E$，$E$ 和所有的 $e_i$ 为实数。

数据更新日志

• 2010/xx/xx：原版数据；

• 2018/03/02：@kczno1 添加了 一组数据；

• 2018/04/20：@X_o_r 添加了 一组数据；

• 2021/01/08：@LeavingZ 添加了 两组数据。

题解代码

学会利用新知，自己多试试并尝试积攒一些固定解答方案，debug，以下是题解代码 ~

# include <bits/stdc++.h>
using namespace std;
typedef long long ll;

template <class Num> inline void Cmax(Num &x, const Num y) {
	x = y > x ? y : x;
}

template <class Num> inline void Cmin(Num &x, const Num y) {
	x = y < x ? y : x;
}

const int maxn(5005);
const int maxm(2e5 + 5);
const double eps(1e-8);

int n, m, first[maxn], cnt, vis[maxn], rt[maxn], tot, cov[maxm << 1], ans, fa[maxn];
double se, e, dis[maxn];
priority_queue < pair <double, int> > q;

struct Heap {
	int ls, rs, dis, ed;
	double w;
} tr[maxm * 20];

struct Edge {
	int to, next;
	double w;
} edge[maxm << 1];

inline void Add(int u, int v, double w) {
	edge[cnt] = (Edge){v, first[u], w}, first[u] = cnt++;
	edge[cnt] = (Edge){u, first[v], w}, first[v] = cnt++;
}

inline int NewNode(double w, int ed) {
	int x = ++tot;
	tr[x].w = w, tr[x].dis = 1, tr[x].ed = ed;
	return x;
}

int Merge(int x, int y) {
	if (!x || !y) return x + y;
	if (tr[x].w - tr[y].w >= eps) swap(x, y);
	int p = ++tot;
	tr[p] = tr[x], tr[p].rs = Merge(tr[p].rs, y);
	if (tr[tr[p].ls].dis < tr[tr[p].rs].dis) swap(tr[p].ls, tr[p].rs);
	tr[p].dis = tr[tr[x].rs].dis + 1;
	return p;
}

void Dfs(int u) {
	vis[u] = 1;
	for (int e = first[u], v; e != -1; e = edge[e].next)
		if (e & 1) {
			double w = edge[e].w;
			if (fabs(dis[u] + w - dis[v = edge[e].to]) < eps && !vis[v])
				fa[v] = u, cov[e ^ 1] = 1, Dfs(v);
		}
}

int main() {
	memset(first, -1, sizeof(first));
	memset(dis, 127, sizeof(dis));
	scanf("%d%d%lf", &n, &m, &se);
	for (int i = 1, u, v; i <= m; ++i) scanf("%d%d%lf", &u, &v, &e), Add(u, v, e);
	dis[n] = 0, q.push(make_pair(0, n));
	while (!q.empty()) {
		int u = q.top().second;
		q.pop();
		if (vis[u]) continue;
		vis[u] = 1;
		for (int e = first[u]; ~e; e = edge[e].next)
			if (e & 1) {
				int v = edge[e].to;
				if (dis[v] - (dis[u] + edge[e].w) >= eps)
					q.push(make_pair(-(dis[v] = dis[u] + edge[e].w), v));
			}
	}
	for (int i = 1; i <= n; ++i) vis[i] = 0;
	Dfs(n);
	for (int e = 0, u, v; e < cnt; e += 2)
		if (!cov[e]) {
			u = edge[e ^ 1].to, v = edge[e].to;
			if (dis[u] == dis[0] || dis[v] == dis[0]) continue;
			rt[u] = Merge(rt[u], NewNode(dis[v] + edge[e].w - dis[u], v));
		}
	for (int i = 1; i <= n; ++i) q.push(make_pair(-dis[i], i));
	for (int i = 1, u; i <= n; ++i) {
		u = q.top().second, q.pop();
		if (fa[u]) rt[u] = Merge(rt[u], rt[fa[u]]);
	}
	if (dis[1] - se < eps) se -= dis[1], ++ans;
	if (rt[1]) q.push(make_pair(-tr[rt[1]].w, rt[1]));
	while (!q.empty()) {
		int ed = q.top().second;
		double cur = q.top().first, w = dis[1] - cur;
		if (w - se >= eps) break;
		q.pop(), se -= w, ++ans;
		for (int i = 0; i < 2; ++i) {
			int nxt = i ? tr[ed].rs : tr[ed].ls;
			if (nxt) q.push(make_pair(cur + tr[ed].w - tr[nxt].w, nxt));
		}
		if (rt[tr[ed].ed]) q.push(make_pair(cur - tr[rt[tr[ed].ed]].w, rt[tr[ed].ed]));
	}
	printf("%d\n", ans);
	return 0;
}

我的一些话

• 今天学习动态规划，dp属于比较难的部分，这题利用记忆化搜索即可快速解决，需要多动脑，多思考思路还是很好掌握的，虽然一次性AC有一定难度，需要通盘的考虑和理解，以及扎实的数据结构基础才能独立写出AC代码。但无论难易，大家都要持续做题，保持题感喔！一起坚持(o´ω`o)

• 如果有非计算机专业的uu自学的话，关于数据结构的网课推荐看b站上青岛大学王卓老师的课，讲的很细致，有不懂都可以私信我喔

• 总结来说思路很重要，多想想，多在草稿纸上画画，用测试数据多调试，debug后成功编译并运行出正确结果真的会感到很幸福！

• 关于之前蓝桥杯备赛的路线和基本方法、要掌握的知识，之前的博文我都有写，欢迎大家关注我，翻阅自取哦~

• 不管什么都要坚持吧，三天打鱼两天晒网无法形成肌肉记忆和做题思维，该思考的时候一定不要懈怠，今天就说这么多啦，欢迎评论留言，一起成长：）