算法学习笔记（13）：同余最短路

合集 - 算法(31)

1.算法学习笔记（1）：CDQ分治2023-11-172.算法学习笔记（2）：分块2023-11-303.算法学习笔记（3）：莫队算法2024-01-014.算法学习笔记（4）：FHQ平衡树（无旋平衡树）2024-01-015.算法学习笔记（5）：AC自动机2024-01-016.算法学习笔记（6）：优秀trick和性质合集2024-03-097.算法学习笔记（7）：数论2024-03-098.算法学习笔记（9）：第k大问题合集2024-03-169.算法学习笔记（10）：各种序的美好性质2024-03-1610.算法学习笔记（11）：历史版本和线段树2024-03-3111.算法学习笔记（12）：左偏树2024-04-08

12.算法学习笔记（13）：同余最短路2024-04-12

13.算法学习笔记（14）：区间最值操作和历史最值问题2024-04-2814.算法学习笔记（15）： Splay树2024-05-0615.算法学习笔记（16）：Link Cut Tree2024-05-0716.算法学习笔记（17）：Slope trick2024-05-1017.算法学习笔记（18）：珂朵莉树2024-05-1318.算法学习笔记（20）：网络流2024-05-1719.算法学习笔记（21）：数论分块2024-06-0620.算法学习笔记（22）：莫比乌斯反演2024-06-0621.算法学习笔记（23）：杜教筛2024-06-0722.算法学习笔记（24）：筛法2024-06-0823.暑假集训学习笔记（1）：lxl DS Day 12024-07-0224.暑假集训学习笔记（2）：lxl DS Day 22024-07-0225.暑假集训学习笔记（3）：lxl DS Day 32024-07-0426.多项式笔记2024-07-0827.生成函数笔记2024-07-0828.插头DP2024-07-2529.DP选讲做题记录 by 付乙淼2024-07-2630.拓展摩尔投票2024-09-1831.图论知识总结2024-09-25

收起

同余最短路

是一种通过同余把状态分类， 再通过建图跑最短路解决问题的算法。可以高效率解决一些特定的问题。 非常的奇妙。

算法

鉴于学不懂， 所以直接搬 $oi-wiki$ 的题吧。 呜呜呜。

P3403 跳楼机

有一栋高为 $h$ 的楼， 初始在一楼， 每次可以向上移动 $x$， $y$， $z$ 层， 也可以回到一楼， 询问可以到达楼层的数量。
转化问题， 可以看成有多少个 $i$， 满足 $i=ax+by+cz$， 考虑如果可以跳到1， 那么 $1+x$， $1+x+x$...，
都可以跳到， 可以跳到 $2$， 那么 $2+x$， $2+x+x$...都可以跳到， 并且答案不重复， 所以考虑按 $modx$ 的剩余系来， 分段统计答案， 我们只需要计算 $pmodx=i$能跳到的最低楼层， 因为有些跳不到。
如果这里懂了， 那么建边也就懂了。

1. $i->(i+y)modx$ 边权为 $y$。
2. $i->(i+z)modz$ 边权为 $z$。

最后从 $1$ 开始跑最短路。 再统计答案就可以了。

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 1e5 + 10;
const ll INF = LONG_LONG_MAX; 
int X, Y, Z, head[N], tot, vis[N];
ll H, d[N];
struct Edge{ int to, dis, nxt; }edge[N << 3];
void add(int x, int y, int z) { edge[++tot] = {y, z, head[x]}; head[x] = tot; }
#define fi first
#define se second
priority_queue< pair<ll, int> > q;
void dijk(int s) {
	fill(d, d + X, INF);
	d[s] = 1; q.push({-d[s], s});
	while (!q.empty()) {
		int u = q.top().se; q.pop();
		if (vis[u]) continue;
		vis[u] = 1;
		for (int i = head[u]; i; i = edge[i].nxt) {
			int v = edge[i].to;
			if (!vis[v] && d[u] + edge[i].dis < d[v]) {
				d[v] = d[u] + edge[i].dis;
				q.push({-d[v], v});
			}
		} 
	}
}
int main() {
	scanf("%lld%d%d%d", &H, &X, &Y, &Z);
	if (X == 1 || Y == 1 || Z == 1) {
    	printf("%lld\n", H);
    	return 0;
  	}
	for (int i = 0; i < X; i++) {
		add(i, (i + Y) % X, Y);
		add(i, (i + Z) % X, Z);
	}
	dijk(1);
	ll ans = 0; 
	for (int i = 0; i < X; i++) if (H >= d[i]) ans += (H - d[i]) / X + 1;
	printf("%lld", ans);
	return 0;
}

[ABC077D] Small Multiple

输出 $K$ 的正整数倍的最小数位累加和。

考虑很难办， 最质朴的做法就是枚举左右的倍数， 显然不行。 但是我们把所有数按数位和分类， $sum=1$ 的有$1,10,100,1000...$, $sum=2$ 的有 $2,11,101,110,1001...$， 这样就会很难发现一个性质， 一个数一定可以由 若干$+1$， $\times 10$操作过来， 且 $+1$操作产生1的代价， $\times 10$ 不产生代价， 这时候就可以跑同余最短路， 并且这还是01图， 直接01BFS就可以做到时间复杂度 $O(E)$。 答案就是 $1$ 到 $0$ 的最短路， 严谨的你会发现， 如果连续跑10次边权为$1$的边， 得出来的答案不是错的？这种情况显然不合法， 但是我们跑的是最短路， 跑10次边权为1的边， 肯定不优。 所以不影响答案。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int K, d[N], vis[N];
#define pf push_front
#define pb push_back
#define ls ((u * 10) % K)
#define rs ((u + 1) % K)
deque<int> q;
void bfs(int s) {
	memset(d, 0x3f, sizeof d);
	q.pb(s); d[s] = 1;
	while (!q.empty()) {
		int u = q.front(); q.pop_front();
		if (u == 0) printf("%d", d[u]), exit(0);
		vis[u] = 1;
		if (!vis[ls] && d[ls] > d[u]) d[ls] = d[u], q.pf(ls);
		if (!vis[rs] && d[rs] > d[u] + 1) d[rs] = d[u] + 1, q.pb(rs);
	}
}
int main() {
	scanf("%d", &K);
	bfs(1);
	return 0;
}

牛场围栏

考虑和跳楼机十分相似， 我们钦定一个最小的木棍为模数 $Min$ (因为这样边数最少)， 然后$O(N\times M\times MIN)$求建图跑同余最短路， 就可以找到每一个同余类的最小的可以围成的围栏， $-Min$就是最大的不能围成的围栏。

墨墨的等式

考虑是牛场围栏和跳楼机的整合版， 答案统计的时候魔改一下就行了。