「2019纪中集训Day4」解题报告
T1、forging
勇者虽然武力值很高，但在经历了多次战斗后,发现怪物越来越难打。
于是开始思考是不是自己平时锻炼没到位,于是苦练一个月后发现......自己连一个史莱姆都打不过了。
勇者的精灵路由器告诉勇者其实是他自己的武器不好，并把他指引到了锻造厂。
“欢迎啊，老朋友。”
一阵寒暄过后，厂长带他们参观了厂子四周，并给他们讲锻造的流程。
“我们这里的武器分成若干的等级，等级越高武器就越厉害，并且对每一等级的武器都有两种属性值 \(b\) 和 \(c\)，但是我们初始只能花 \(a\) 个金币来生产 \(1\) 把 \(0\) 级剑......”
“你们厂子怎么这么垃圾啊，不能一下子就造出来 \(999\) 级的武器吗?”勇者不耐烦的打断了厂长的话。
“别着急，还没开始讲锻造呢......举例你手中有一把 \(x\) 级武器和一把 \(y\) 级武器 \((y = \max(x - 1, 0))\)，令锻造附加值 \(k = \min(c_x , b_y)\)，则有 \(\frac{k}{c_x}\) 的概率将两把武器融合成一把 \(x + 1\) 级的武器。”
“......但是，锻造不是一帆风顺的，你同样有 \(1 - \frac{k}{c_x}\) 的概率将两把武器融合成一把 \(\max(x - 1, 0)\) 级的武器......”
勇者听完后暗暗思忖，他知道厂长一定又想借此机会坑骗他的零花钱,于是求助这个村最聪明的智者——你，来告诉他,想要强化出一把 \(n(n \le 10^7)\) 级的武器，其期望花费为多少?
由于勇者不精通高精度小数，所以你只需要将答案对 \(998244353\) ( \(7 \times17 \times 2^{23} + 1\)，一个质数 ) 取模即可。
\(Sol\)：
记 \(f_i\) 表示造出一把 \(i\) 级武器的期望代价，\(p_i\) 表示强化 \(i\) 武器时成功的概率；
通过推导不难得出：\(f_i = \frac{1}{p} f_{i - 1} + f_{i - 2}\)。
要注意常数因子带来的影响。
\(Source\)：
#include <cstdio>
int in() {
int x = 0; char c = getchar(); bool f = c == '-';
while (c < '0' || c > '9')
f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return f ? -x : x;
}
template<typename T>inline void chk_min(T &_, T __) { _ = _ < __ ? _ : __; }
template<typename T>inline void chk_max(T &_, T __) { _ = _ > __ ? _ : __; }
const int N = 1e7 + 5, mod = 998244353;
int n, A, a[N], b[N], c[N], f[N], inv[N];
int qpow(int base, int b, int ret = 1) {
for (; b; b >>= 1, base = 1ll * base * base % mod)
if (b & 1)
ret = 1ll * ret * base % mod;
return ret;
}
inline int min(int _, int __) { return _ < __ ? _ : __; }
inline int max(int _, int __) { return _ > __ ? _ : __; }
int main() {
// freopen("in", "r", stdin);
freopen("forging.in", "r", stdin);
freopen("forging.out", "w", stdout);
n = in(), A = in();
int bx = in(), by = in(), cx = in(), cy = in(), p = in();
b[0] = by + 1, c[0] = cy + 1;
for(int i = 1; i < n; ++i) {
b[i] = (1ll * b[i - 1] * bx + by) % p + 1;
c[i] = (1ll * c[i - 1] * cx + cy) % p + 1;
}
inv[1] = 1;
for (int i = 2; i <= p; ++i)
inv[i] = 1ll * (mod - (mod / i)) * inv[mod % i] % mod;
f[0] = A;
for (int i = 1; i <= n; ++i) {
f[i] = 1ll * inv[min(b[max(i - 2, 0)], c[i - 1])] * c[i - 1] % mod * f[i - 1] % mod + f[max(i - 2, 0)];
if (f[i] >= mod)
f[i] -= mod;
}
printf("%d\n", f[n]);
return 0;
}
T2、division
整除符号为 \(|\)，\(d|n\) 在计算机语言中可被描述为 \(n \% d == 0\)。
现有一算式 \(n | x^m − x\)，给定 \(n\)，\(m\)，求 \([1, n]\) 以内 \(x\) 解的个数。
解可能很大，输出取模 \(998244353\)。
其中 \(n\) 的给定方式是由 \(c\) 个不超过 \(t\) 的质数的乘积给出的，\(c(c \le 10 ^ 4)\) 和 \(t\) 的范围会在数据范围中给出。
第一行一个 \(id\) 表示这个数据点的标号。
多组数据，其中第二行一个整数 \(T\) 表示数据组数。
对于每一组数据：
第一行两个整数 \(c\) 和 \(m(m \le 10 ^ 9)\)。
第二行 \(c\) 个整数 \(p_i (p_i \le 10 ^4)\)，这些整数都是质数，且两两不同，他们的乘积即为\(n\)。
由于你可以通过输入求出 \(t\)，输入不再给出。
\(Sol_1\)：
首先根据题意可以得到 \(c\) 个形如 \(x ^ m \equiv x \ (mod \ p_i)\) 方程组：
对于第 \(i\) 个方程，可以暴力枚举 \(p_i\) 以内的所有正整数，设得到的解的个数为 \(t_i\)；
答案为 \(\Pi t_i\)，时间复杂度 \(O(T \ c \ p_i)\)；
简单证明：
对于每个 \(i\)，\(t_i\) 个解可以看做 \(t_i\) 个形如 \(s_{i,j} \equiv 0 \ (mod \ p_i)\) 的方程组；
现在对于每一个 \(i\) 都选出一个解(即上述方程组中的一个)，可以得到一个新的方程组；
这个新的方程组在 \(n\) 以内只有一个正整数解，\(QED\)。
\(Source\)：
//#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include <cstdio>
int in() {
int x = 0; char c = getchar(); bool f = c == '-';
while (c < '0' || c > '9')
f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return f ? -x : x;
}
template<typename T>inline void chk_min(T &_, T __) { _ = _ < __ ? _ : __; }
template<typename T>inline void chk_max(T &_, T __) { _ = _ > __ ? _ : __; }
int c, n, m;
const int N = 1e4 + 5, mod = 998244353;
int f[N], min_prime[N], pri[N];
void init_prime() {
for (int i = 2; i < N; ++i) {
if (!min_prime[i]) {
min_prime[i] = i;
pri[++pri[0]] = i;
}
for (int j = 1; j <= pri[0] && i * pri[j] < N; ++j) {
min_prime[i * pri[j]] = pri[j];
if (i % pri[j] == 0)
break;
}
}
}
int qpow(int base, int b, int ret = 1, int p = mod) {
for (; b; b >>= 1, base = 1ll * base * base % p)
if (b & 1)
ret = 1ll * ret * base % p;
return ret;
}
int main() {
// freopen("in", "r", stdin);
freopen("division.in", "r", stdin);
freopen("division.out", "w", stdout);
int id = in(), T = in();
init_prime();
while (T--) {
c = in(), m = in();
int res = 1;
for (int i = 1; i <= c; ++i) {
n = in();
int tmp = 2;
f[1] = 1;
for (int i = 2; i < n; ++i) {
if (i == min_prime[i])
f[i] = qpow(i, m, 1, n);
else
f[i] = 1ll * f[min_prime[i]] * f[i / min_prime[i]] % n;
if (f[i] == i)
++tmp;
}
res = 1ll * res * tmp % mod;
}
printf("%d\n", res);
}
return 0;
}
\(p.s.\)关于这个做法好像假了，我这两天再证一下 (2019-08-06)。
\(Sol_2\)：
由于 \(p\) 是质数，\([1,p-1]\) 的所有整数都可以表示为 \(g ^ y\)；
所以方程组可以写成 \(g^{my} \equiv g^y \ (mod \ (p - 1))\)。
根据费马小定理：
两边同时除以 \((m - 1, p - 1)\)，令 \(d=(m - 1, p - 1)\)：
由于 \(y \in [0, p - 2]\)，所以 \(\frac{p - 1}{d}\) 的任意小于 \(d\) 的非负整数倍都符合条件；
所以第 \(i\) 个方程的解个数为 \(d + 1\)，\(x = p\) 显然是唯一一个没有被算到的解。
时间复杂度 \(O(T \ c \ log p)\)；
\(Source\)：
#include <cstdio>
int in() {
int x = 0; char c = getchar(); bool f = c == '-';
while (c < '0' || c > '9')
f |= c == '-', c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return f ? -x : x;
}
template<typename T>inline void chk_min(T &_, T __) { _ = _ < __ ? _ : __; }
template<typename T>inline void chk_max(T &_, T __) { _ = _ > __ ? _ : __; }
const int mod = 998244353;
int c, n, m;
int gcd(int a, int b) {
return b ? gcd(b, a % b) : a;
}
int main() {
// freopen("in", "r", stdin);
freopen("division.in", "r", stdin);
freopen("division.out", "w", stdout);
int id = in(), T = in();
while (T--) {
c = in(), m = in();
int res = 1;
for (int i = 1; i <= c; ++i)
res = 1ll * res * (gcd(in() - 1, m - 1) + 1) % mod;
printf("%d\n", res);
}
return 0;
}
T3、money
有 \(n(n \le 10 ^ 5)\) 个点，\(m(m \le 10 ^ 6)\) 次操作；
有两种操作：
\(0\)：\(a\) 向 \(b\) 连一条边权为 \(c\) 的有向边；
\(1\)：查询 \(a\) 到 \(b\) 的通路上的最小值，若没有通路则输出 \(0\)。
保证每个点只会连出去一条边，强制在线。
\(Sol_1\)：
因为最后一句话的限制，显然这是一棵树，且方向为儿子到父亲，考虑倍增；
每次合并两棵树时考虑启发式合并(重新计算点数较小的树的倍增数组)，此时当做无根树，还要记录一下是否是父亲走向儿子的边；
由于每个点只有在该点所在联通块的大小 更新为至少原来的两倍时 才会重新计算它的倍增数组；
所以时间复杂度为 \(O(n \ log ^2 n + m \ log n)\)；
没写，所以没有代码；
\(Sol_2\)：
因为倍增数组里的信息只会增加，所以只要做到添加信息时做到不重复，时间复杂度仍是 \(O(nlogn)\)。
对于一棵树，可以用 \(vector\) 等数据结构来维护同一深度的点；
对于 \(u\) 子树中每一层节点，记录每一层已经有 \(k\) 级祖先的信息，每次连一条 \(u\) -> \(v\) 的边 (\(u\) 为子节点)，从 \(k + 1\) 级祖先开始增加信息即可；
没写。
\(Sol_3\)：
\(lct\) 裸题。
\(lct\) 维护 \(a,b\) 两点的 \(lca\)：\(access(a)\)，\(access(b)\) 时最后一次进行 \(splay\) 操作的点就是 \(lca\)。
时间复杂度 \(O(m \ logn)\)，由于 \(lct\) 的超大常数，考场只拿了 \(80\) 分，要大力卡常开 \(O_3\)才能过(第一次加输出优化变快，快了近 \(2.1s\))。
\(Source\)：
//#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#include <cstdio>
#include <cstring>
inline char get_char(){
static char buf[100000],*p1=buf,*p2=buf;
return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
int in() {
register int x = 0; register char c = get_char();
while (c < '0' || c > '9')
c = get_char();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = get_char();
return x;
}
void out(register int x) {
if (x > 9)
out(x / 10);
putchar(x % 10 + '0');
}
inline void out_ln(register int x) {
out(x), puts("");
}
template<typename T>inline void chk_min(T &_, T __) { _ = _ < __ ? _ : __; }
template<typename T>inline void chk_max(T &_, T __) { _ = _ > __ ? _ : __; }
const int N = 1e5 + 5, inf = 0x3f3f3f3f;
int n, m, lastans, pre[N];
int get_fa(int u) {
return pre[u] == u ? u : pre[u] = get_fa(pre[u]);
}
//link_cut_tree begin
int fa[N], c[N][2], val[N], min[N];
bool rev[N];
inline bool nroot(register int p) {
return c[fa[p]][0] == p || c[fa[p]][1] == p;
}
inline void push_up(register int p) {
min[p] = val[p];
chk_min(min[p], min[c[p][0]]);
chk_min(min[p], min[c[p][1]]);
}
inline void rever(register int p) {
register int t = c[p][0]; c[p][0] = c[p][1], c[p][1] = t;
rev[p] ^= 1;
}
inline void push_down(register int p) {
if (rev[p]) {
if (c[p][0])
rever(c[p][0]);
if (c[p][1])
rever(c[p][1]);
rev[p] = 0;
}
}
void push_all(int p) {
if (nroot(p))
push_all(fa[p]);
push_down(p);
}
void rotate(register int x) {
register int y = fa[x], z = fa[y], l = c[y][1] == x, r = l ^ 1;
if (nroot(y))
c[z][c[z][1] == y] = x;
fa[x] = z, fa[y] = x;
if (c[x][r])
fa[c[x][r]] = y;
c[y][l] = c[x][r], c[x][r] = y;
push_up(y), push_up(x);
}
void splay(register int x) {
register int y, z;
push_all(x);
while (nroot(x)) {
y = fa[x], z = fa[y];
if (nroot(y))
rotate(c[y][0] == x ^ c[z][0] == y ? x : y);
rotate(x);
}
}
int access(register int p) {
register int ret;
for (register int t = 0; p; p = fa[t = p])
splay(p), c[p][1] = t, push_up(p), ret = p;
return ret;
}
inline void make_root(register int p) {
access(p), splay(p), rever(p);
}
inline void split(register int p, register int t) {
make_root(p), access(t), splay(t);
}
inline void link(register int p, register int t) {
splay(p), fa[p] = t;
val[p] = (in() + lastans) % n + 1;
chk_min(min[p], val[p]);
}
inline int query(register int a, register int b) {
register int ret = 0;
access(b);
if (access(a) == b) {
make_root(b);
access(a), splay(b);
ret = min[c[b][1]];
make_root(get_fa(b));
}
return ret;
}
//link_cut_tree end
int main() {
// freopen("in", "r", stdin);
freopen("money.in", "r", stdin);
freopen("money.out", "w", stdout);
n = in(), m = in();
for (register int i = 1; i <= n; ++i)
pre[i] = i;
memset(val, inf, sizeof(val));
min[0] = val[0];
while (m--) {
if (in()) {
int a = (in() + lastans) % n + 1, b = (in() + lastans) % n + 1;
// printf("%d %d\n", a, b);
if (get_fa(a) == get_fa(b))
lastans = query(a, b);
else
lastans = 0;
out_ln(lastans);
} else {
int a = (in() + lastans) % n + 1, b = (in() + lastans) % n + 1;
link(a, b);
pre[a] = b;
}
}
return 0;
}
