闲话 22.10.28

闲话

明日CSP，而我连廊桥都不会分配
我是不是要抱泠了

于是今日晚上写一些板子

480p
soytony：斯大林p
这是什么新p主能不能各位给我科普一下

今日歌词是摘了美影日记里新的那部分！
今天推的歌是美影日记！希望各位能去看看新的pv！

雨のち曇り晴れ

優しくきっと晴れ

きらきら浮かぶ言葉

もう忘れちゃうけれど

杂题

给定两个整数 \(n, m\) 和两个字符串 \(w_1, w_2\)。\(n\) 是两个字符串的长度，\(m\) 是答案 \(P\) 的下界，\(n, m \le {10}^5\)。

定义 Hash 函数如下

\[H_p(w)=\sum_{i=0}^{|w|-1}w_ir^i\bmod P \]

其中 \(P\) 是一个质数。

请你寻找任意一对 \(P,r\) 满足 \(H_p(w_1)=H_p(w_2)\)，题目保证至少存在一组可行解。

\(m\leqslant P\leqslant 10^9\)，\(2\leqslant r\leqslant P-2\)。

仍然是翻译的官方题解。

问题可以被简单陈述如下：给定一个整系数多项式 \(f(x) = \sum_{i=0}^{n-1} f_ix^i\)，找到一个大质数 \(p\) 以及 \(r \in [2, p-2]\) 使得 \(f(r) \equiv 0 \pmod p\)。

一种解法是随机找到一个质数 \(p\)，并依次检查所有 \(r\) 的取值。由于对于 \(r\) 的随机值来说 \(f(r) \text{ mod } p\) 也可以被认为是随机的，因此我们可以粗略地认为所有 \(r\) 都不满足要求的概率为

\[\left(1-\frac 1p\right)^p \approx e^{-1} \ge \frac 13 \]

因此我们只需重复 \(O(1)\) 次质数的选取。使用多项式多点求值能做到大常数的 \(O(n \log^2 n)\)。这足以解决问题，但这不是最优秀的做法，也不是最优雅的方法 : )

下面将讲述另一种做法。我们令 \(d\) 为 \(p-1\) 的任意因子。众所周知，在模 \(p\) 整数域内有恰好 \(d\) 个元素 \(r\) 满足

\[r^d \equiv 1 \pmod p \]

注意到如果 \(r\) 是这样一个元素，则以 \(d=3\) 为例，有

\[r^{10} + r^5 \equiv r^{3\times 3 + 1} + r^{3+2} \equiv (r^3)^3 \times r + r^3\times r^2\equiv r +r^2 \pmod p \]

事实上，如果我们将这一性质应用到整个多项式上，我们就可以将同余项的系数合并，得到一个更小度数的多项式

\[f^{(d)}(r) = \sum_{i=0}^{d-1}\alpha_ir^i \]

这样求 \(d\) 个点只需要 \(O(d^2)\) 的复杂度。

当前算法的过程如下：寻找一个小整数 \(d\)，选择一个形如 \(kd+1\) 的质数 \(p > m\)，随后找到所有满足 \(r^d \equiv 1\pmod p\) 的整数 \(r\)，随后对这些位置求解 \(f^{(d)}(r)\) 的值，祈祷着得到的值是 \(0\)。
决定性的 trick 就是既然 \(f^{(d)}\) 的系数能被一劳永逸地算出来，我们就可以对大量质数分别在 \(O(d^2)\) 的复杂度内计算所有的 \(r\) 位置对应的值。
注意到，如果我们还相信 \(f^{(d)} \pmod p\) 的值是随机的（而且我们必须要相信），那大致上 \(\frac md\approx \frac {10^5}d\) 个质数就应当足够了。

还剩下两个问题：1. 我们该选什么样的数 \(d\)？ 2. 我们该如何找到满足 \(r^d \equiv 1 \pmod p\) 的整数 \(r\)？
对于 1. ，我们发现最好的选择就是那些小质数，例如 \(3,5,7,11,\cdots\)。这样我们就能留下大量形如 \(kd+1\) 的质数 \(p\)，而且 \(O(d^2)\) 的时间复杂度开销也不会很大。
对于 2. ，当选好了 \(d\) 后找到满足如上条件的整数 \(r\) 也不是很难。我们随机一个整数 \(r_0\)，取 \(r_0^{\frac{p-1}d}\) 为对应整数。正确性考虑费马小定理。这一步实际选出并在之后使用的数是 \(r_0^{\frac{p-1}d}\)，因此其不可等于 \(1\)。

具体地说，以下流程的算法跑得很好：

1. 选择一个质数 \(d\) 以及一个质数 \(p = kd+1\)。
2. 从 \(r\in \{1, 2, \dots, p-1\}\) 中随机抽取一个值。
3. 若 \(r^{\frac {p-1} d} \neq 1\) 进入下一步，反之回到上一步。
4. 计算模 \(p\) 意义下的 \(f^{(d)}(r), f^{(d)}(r^2),\dots f^{(d)}(r^d)\)。

可以证明，上述算法一定能够输出我们想要的答案。进一步的，由于每个 \(d\) 会产生 \(O(\frac md)\) 个质数 \(p\)，每个质数 \(p\) 能够验证 \(O(d^2)\) 个数字，因此取得 \(d\) 但无法得到所需答案的概率为

\[\left(1-\frac 1p\right)^{d^2\times \frac pd} = \left(1-\frac 1p\right)^{pd} \]

可以看到期望复杂度很优秀。

code

#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,a,b) for (register int i = (a), i##_ = (b) + 1; i < i##_; ++i)
#define pre(i,a,b) for (register int i = (a), i##_ = (b) - 1; i > i##_; --i)
const int N = 1e6 + 10;
int n, m, str[N];
char s[N], t[N]; 
 
int prime[N], cnt; bool vis[N];
void sieve(int bnd) {
    rep(i,2,bnd) {
        if (!vis[i]) prime[++cnt] = i;
        rep(j,1,cnt) {
            if (i * prime[j] > bnd) break;
            vis[i * prime[j]] = 1;
            if (i % prime[j] == 0) break;
        } 
    }
}
 
int qp(int a, int b, int mod) {
    int ret = 1;
    while (b) {
        if (b & 1) ret = 1ll * ret * a % mod;
        a = 1ll * a * a % mod;
        b >>= 1;
    } return ret;
}
 
int a[N];
void check(int d) {
    rep(i,0,d-1) a[i] = 0;
    rep(i,0,n) a[i % d] += str[i];
    for (int p = m / d * d + d + 1; p < 1e6; p += d) if (!vis[p]) {
        int r, r0;
        while (true) {
            r = rand() * rand() % (p - 2) + 1;
            r0 = qp(r, (p-1) / d, p); 
            if (r0 == 1) continue;
            // cout << r << ' ' << r0 << endl;
            r = r0;
            rep(tmp,1,d) {
                int t = 0, bse = 1;
                rep(i,0,d-1) t = (t + 1ll * bse * a[i]) % p, bse = 1ll * bse * r % p;
                if (t == 0) { cout << p << ' ' << r << endl; exit(0); }
                r = 1ll * r0 * r % p;
            }
            break;
        }
    }
}
 
signed main() {
    ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    cin >> n >> m >> s+1 >> t+1;
    rep(i,1,n) str[i] = s[i] - t[i];
    sieve(1e6);
    rep(i,2,cnt) check(prime[i]);
}

---

CF1276D

给定一棵\(n\)个点的树，点编号\(1 \sim n\)，第\(i\)条边连接\(a_i\)和\(b_i\)。初始时你有一个空的序列，树上的\(n\)个点都有标记。现在按照边的编号从小到大考虑每一条边：

• 如果这一条边连接的两个点都有标记，则选择其中的一个点，擦除它的标记并将它的编号放入序列的末端；

• 否则什么都不做。

求能够由上述操作得到的不同的序列数量\(\bmod 998244353\)。

\(n \le 2\times 10^5\)

dp 题。

由于加边是有顺序的，考虑按照时间设计 dp 数组状态。

我们称一条边覆盖了一个点，当且仅当这条边擦除了这个点的标记。
然后设 \(f_{i,j}\) 为 \(i\) 节点子树的状态数，\(j\) 规定了 \(i\) 节点状态被擦除的情况。

1. \(j=0\) 表示该节点被连向父亲的边前的连向儿子的边覆盖。
2. \(j=1\) 表示该节点被连向父亲的边覆盖。
3. \(j=2\) 表示该节点被连向父亲的边后的连向儿子的边覆盖。
4. \(j=3\) 表示该节点没有被覆盖。

然后转移。

首先讨论被连向儿子的边覆盖。
枚举覆盖边连向的儿子。这个儿子 \(y\) 一定是在被连向父亲的边后被覆盖。转移值有 \(f_{y,2/3}\)。然后枚举其他儿子。对应边编号在 \(y\) 之前的点 \(z\) 一定要被覆盖，转移值有 \(f_{z,0/1}\)，在 \(y\) 之后的点 \(z\) 不一定被覆盖，转移值有 $f_{z,0/2/3}。
先不考虑 \(j\) 的取值对 \(y\) 的限制，列出转移式：

\[f_{x,0/2} = \sum_{y} \left( (f_{y,2} + f_{y,3})\times \prod_{z < y} (f_{z,0} + f_{z,1}) \times \prod_{z \ge y} (f_{z,0} + f_{z,2}+f_{z,3}) \right) \]

限制自行加入。

然后讨论被父亲覆盖。
由于当前节点是被父亲覆盖的，因此其孩子中所有小于父亲的边都不能在覆盖当前节点后再覆盖。由于这条边不会删除当前节点，因此当前边只能擦除子节点。因此转移 \(f_{y,0/1}\) 。
相似的讨论说明对于大于父亲的节点不能选择 \(f_1\)，因此转移 \(f_{y,0/2/3}\)。

\[f_{x,1} = \prod_{z < fa} (f_{z,0} + f_{z,1}) \times \prod_{z \ge fa} (f_{z,0} + f_{z,2}+f_{z,3}) \]

然后讨论未被覆盖。
？

\[f_{x,3} = \prod_{y} (f_{z,0} + f_{z,1}) \]

转移即可。

code

#include <bits/stdc++.h>
using namespace std;
#ifdef ONLINE_JUDGE
    char buf[1<<21], *p1 = buf, *p2 = buf;  inline char getc() { return (p1 == p2 and (p2 = (p1 = buf) + fread(buf, 1, 1<<21, stdin), p1 == p2) ? EOF : *p1++); }
    #define getchar getc
#endif
template <typename T> inline void get(T & u){
	u = 0; char ch = getchar(); bool f = 0; while (ch < '0' or ch > '9') f = f or ch == '-',  ch = getchar();
	while (ch >= '0' and ch <= '9') u = (u<<1) + (u<<3) + (ch^48), ch = getchar(); f and (u = -u);
} template <typename T, typename ... Args> inline void get(T & u, Args & ... _Args) { get(u); get(_Args...); }
#define rep(i,a,b) for (register int i = (a), i##_ = (b) + 1; i < i##_; ++i)
#define pre(i,a,b) for (register int i = (a), i##_ = (b) - 1; i > i##_; --i)
const int N = 5e5 + 10, mod = 998244353;
int n, t1, t2, f[N][4]; 
vector <int> g[N];

void dfs(int u, int fa) {
    for (auto v : g[u]) if (v != fa) dfs(v, u);
    static int cnt, fap, _01[N], _23[N], _023[N];
    cnt = fap = 0; _01[0] = 1;
    for (auto v : g[u]) if (v == fa) fap = cnt;
    else {
        ++cnt;
        _01[cnt] = 1ll * _01[cnt - 1] * (f[v][0] + f[v][1]) % mod;
        _23[cnt] = f[v][2] + f[v][3]; if (_23[cnt] >= mod) _23[cnt] -= mod;
        _023[cnt] = _23[cnt] + f[v][0]; if (_023[cnt] >= mod) _023[cnt] -= mod;
    } 
    _023[cnt + 1] = 1;
    pre(i,cnt - 1,1) _023[i] = 1ll * _023[i + 1] * _023[i] % mod;
    rep(i,1,cnt) 
        if (i <= fap) f[u][0] = (f[u][0] + 1ll * _01[i - 1] * _23[i] % mod * _023[i + 1]) % mod;
        else f[u][2] = (f[u][2] + 1ll * _01[i - 1] * _23[i] % mod * _023[i + 1]) % mod;
    f[u][1] = 1ll * _01[fap] * _023[fap + 1] % mod;
    f[u][3] = _01[cnt];
}

signed main() {
    get(n); rep(i,2,n) get(t1, t2), g[t1].emplace_back(t2), g[t2].emplace_back(t1);
    dfs(1, 0);
    cout << (1ll * f[1][0] + f[1][2] + f[1][3]) % mod;
}