【HNOI 2018】毒瘤
Problem
Description
从前有一名毒瘤。
毒瘤最近发现了量产毒瘤题的奥秘。考虑如下类型的数据结构题:给出一个数组,要求支持若干种奇奇怪怪的修改操作(例如给一个区间内的数同时加上 \(c\),或者将一个区间内的数同时开平方根),并且支持询问区间的和。毒瘤考虑了 \(n\) 个这样的修改操作,并将它们编号为 \(1 \ldots n\)。当毒瘤要出数据结构题的时候,他就将这些修改操作中选若干个出来,然后出成一道题。
当然了,这样出的题有可能不可做。通过精妙的数学推理,毒瘤揭露了这些修改操作之间的关系:有 \(m\) 对「互相排斥」的修改操作,第 \(i\) 对是第 \(u_i\) 个操作和第 \(v_i\) 个操作。当一道题中同时含有 \(u_i\) 和 \(v_i\) 这两个操作时,这道题就会变得不可做。另一方面,当一道题中不包含任何「互相排斥」的操作时,这个题就是可做的。此外,毒瘤还发现了一个规律:\(m − n\) 是一个很小的数字(参见「数据范围」中的说明),且任意两个修改操作都是连通的。两个修改操作 \(a, b\) 是连通的,当且仅当存在若干操作 \(t_0, t_1, ... , t_l\),使得 \(t_0 = a,t_l = b\),且对任意 \(1 \le i \le l\),\(t_{i−1}\) 和 \(t_i\) 都是「互相排斥」的修改操作。
一对「互相排斥」的修改操作称为互斥对。现在毒瘤想知道,给定值 \(n\) 和 \(m\) 个互斥对,他一共能出出多少道可做的不同的数据结构题。两个数据结构题是不同的,当且仅当其中某个操作出现在了其中一个题中,但是没有出现在另一个题中。
Input Format
第一行为正整数 \(n, m\)。
接下来 \(m\) 行,每行两个正整数 \(u, v\),代表一对「互相排斥」的修改操作。
Output Format
输出一行一个整数,表示毒瘤可以出的可做的不同的数据结构题的个数。这个数可能很大,所以只输出模 \(998244353\) 后的值。
Sample
Input 1
3 2
1 2
2 3
Output 1
5
Input 2
6 8
1 2
1 3
1 4
2 4
3 5
4 5
4 6
1 6
Output 2
16
Input 3
12 18
12 6
3 11
8 6
2 9
10 4
1 8
6 2
11 5
10 6
12 2
9 3
7 6
2 7
3 2
7 3
5 6
2 11
12 1
Output 3
248
Range
测试点 # | 1~4 | 5~6 | 7~8 | 9 | 10~11 | 12~14 | 15~16 | 17~20 |
---|---|---|---|---|---|---|---|---|
\(n \le\) | \(20\) | \(10^5\) | \(10^5\) | \(3000\) | \(10^5\) | \(3000\) | \(10^5\) | \(10^5\) |
\(m \le\) | \(n + 10\) | \(n - 1\) | \(n\) | \(n + 1\) | \(n + 1\) | \(n + 10\) | \(n + 7\) | \(n + 10\) |
Algorithm
\(DP\),虚树
Mentality
这题真的是,题如其名,我 \(tm\) 码了 \(3.4k......\) 。
我们先来考虑暴力 \(80pts\) (实际上有 \(85pts\) 呢) 。
\(DP\) 式很显然:
当然,\(Ans=f[1][0]+f[1][1]\) 。
不过我们还多出来一些非树边,怎么办?其实很简单,由于非树边两端点会互相影响,那我们只需要枚举每个与非树边相连的点是选还是不选,然后将 \(DP\) 数组的相关值改为 \(0\) ,再做一遍 \(DP\) 即可。
由于每个点的情况与非树边相关,我们只需要枚举每条非树边的左端点 \(u\) (输入中先输入的那个端点) 是选还是不选,如果选,那么将 \(f[u][0]\) 赋值为 \(0\) ,因为我们已经钦定此点会被选择;同理 \(f[v][1]\) 也要赋值为 \(0\) 。而如果 \(u\) 不选,那就不需要再管 \(v\) 了,因为 \(v\) 不受影响。
枚举部分代码如下:
for(int S=0;S<(1<<top);S++)//top 是非树边个数
{
for(int i=1;i<=n;i++)f[i][0]=f[i][1]=1;
for(int i=1;i<=top;i++)//相关值赋为 0
if(S&(1<<(i-1)))
f[U[i]][0]=0,f[V[i]][1]=0;
else
f[U[i]][1]=0;
DP();//DP
ans=(ans+(f[1][0]+f[1][1])%mod)%mod;//加入答案
}
那对于 \(100\) 分的部分分怎么做呢?
其实做过暴力的话,也差不多能想到该优化哪个方面了:每次枚举之后的 \(DP\) 。
因为每次只改变了至多 \(22\) 个点的状态,所以我们应该想办法避免重复计算那些无关的点的 \(DP\) 值。
那显然是 动态dp 建虚树啊 。
那么如何优化点与点的 \(DP\) 计算呢?我们可以发现一件事情:由于 \(DP\) 过程中,我们的运算都是乘法运算,所以在虚树上若有边 \(u->v\) ,则我们必定可以得到
其中 \(a,b,c,d\) 均为可以计算的未知数,不妨将其称之为 \(v\) 在虚树上转移的系数。
我们分别设为 \(k0[v][0],k0[v][1]\) 代表 \(f[v][0]\) 分别为 \(f[u][0],f[u][1]\) 有多少系数的贡献; \(k1[v][0],k1[v][1]\) 同理。
这部分的式子及代码如下:
for(int i=x;fa[i][0]!=y;i=fa[i][0])
{
int Fa=fa[i][0];
work(Fa,i);//计算每层节点不含虚树点的子树的 dp 值
int t0=k0[x][0],t1=k1[x][0];
k0[x][0]=1ll*f[Fa][0]*(t0+k0[x][1])%mod;
k1[x][0]=1ll*f[Fa][0]*(t1+k1[x][1])%mod;
k0[x][1]=1ll*f[Fa][1]*t0%mod;
k1[x][1]=1ll*f[Fa][1]*t1%mod;
}
那么思路就很简单了,求出虚树上每个点到父结点的实际子节点的转移系数,然后 \(DP\) 的时候利用转移系数 \(DP\) 就好。由于虚树的性质,每个点的一棵虚树子树内只会有一个直接相连的点,否则子树内的两个点的 \(lca\) 也会是关键点 \(......\) 所以不用担心转移问题。
求系数详见代码。
虽然题解超级不详细 (没办法题目毒得我不知何去何从) 。
Code
#include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
const int mod = 998244353;
int n, m, ans, fa[100001][18], head[100001], nx[200001], to[200001];
int now, top, cnt, sum, sumk, num, key[23], U[23], V[23], tree[100001],
stack[100001], dfn[100001], deep[100001];
int hd2[100001], nx2[100001], to2[100001], g[100001][2], f[100001][2],
k0[100001][2], k1[100001][2];
bool vis[100001], book[100001];
int find(int x) { return fa[x][0] == x ? x : fa[x][0] = find(fa[x][0]); }
bool cmp(int a, int b) { return dfn[a] < dfn[b]; }
void addroad(int u, int v, int d) {
to[d] = v, nx[d] = head[u];
head[u] = d;
}
void build(int x, int pa) {
deep[x] = deep[pa] + 1, dfn[x] = ++cnt, fa[x][0] = pa;
for (int i = 1; i <= 17; i++) fa[x][i] = fa[fa[x][i - 1]][i - 1];
for (int i = head[x]; i; i = nx[i])
if (to[i] != pa) build(to[i], x);
}
int getlca(int a, int b) {
if (deep[a] < deep[b]) swap(a, b);
for (int i = 17; i >= 0; i--)
if (deep[fa[a][i]] >= deep[b]) a = fa[a][i];
for (int i = 17; i >= 0; i--)
if (fa[a][i] != fa[b][i]) a = fa[a][i], b = fa[b][i];
return a == b ? a : fa[a][0];
}
void link(int a, int b) {
if (!book[a]) tree[++num] = a;
if (!book[b]) tree[++num] = b;
book[a] = book[b] = true, cnt++;
to2[cnt] = b, nx2[cnt] = hd2[a];
hd2[a] = cnt;
}
void Insert(int x) {
int lca = getlca(stack[top], x);
while (top > 1 && dfn[stack[top - 1]] >= dfn[lca])
link(stack[--top], stack[top]);
if (lca != stack[top]) link(lca, stack[top]), stack[top] = lca;
stack[++top] = x;
}
void work(
int x,
int y) //正常计算 dp 值,但是不会计算标记点,标记点一般为含虚树点的子树
{
f[x][0] = f[x][1] = vis[x] = 1;
for (int i = head[x]; i; i = nx[i])
if (to[i] != fa[x][0] && to[i] != y && !vis[to[i]]) {
work(to[i], y);
f[x][0] = 1ll * f[x][0] * (f[to[i]][0] + f[to[i]][1]) % mod;
f[x][1] = 1ll * f[x][1] * f[to[i]][0] % mod;
}
}
void getk(int x, int y) {
vis[x] = k0[x][0] = k1[x][1] = 1;
for (int i = x; fa[i][0] != y; i = fa[i][0]) {
int Fa = fa[i][0];
work(Fa,
i); //层层计算每层的答案,每个节点不含虚树点的子树的 dp 值也会产生贡献
int t0 = k0[x][0], t1 = k1[x][0];
k0[x][0] = 1ll * f[Fa][0] * (t0 + k0[x][1]) % mod;
k1[x][0] = 1ll * f[Fa][0] * (t1 + k1[x][1]) % mod;
k0[x][1] = 1ll * f[Fa][1] * t0 % mod;
k1[x][1] = 1ll * f[Fa][1] * t1 % mod;
}
}
void Count(int x) {
for (int i = hd2[x]; i; i = nx2[i])
Count(to2[i]), getk(to2[i], x); //计算系数
f[x][0] = f[x][1] = 1;
for (int i = head[x]; i; i = nx[i])
if (!vis[to[i]] && to[i] != fa[x][0]) {
work(to[i], 0);
f[x][0] = 1ll * f[x][0] * (f[to[i]][0] + f[to[i]][1]) % mod;
f[x][1] = 1ll * f[x][1] * f[to[i]][0] % mod;
} //计算非虚树部分的 dp 值
}
void DP(int x) {
for (int i = hd2[x]; i; i = nx2[i]) {
int p = to2[i];
DP(p);
int f0 = (1ll * k0[p][0] * g[p][0] + 1ll * k1[p][0] * g[p][1] % mod) % mod;
int f1 = (1ll * k0[p][1] * g[p][0] + 1ll * k1[p][1] * g[p][1] % mod) % mod;
g[x][0] = 1ll * g[x][0] * (f0 + f1) % mod,
g[x][1] = 1ll * g[x][1] * f0 % mod; //直接乘系数计算就好了
}
}
int main() {
cin >> n >> m;
int u, v;
for (int i = 1; i <= n; i++) fa[i][0] = i;
vis[1] = true;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
if (find(u) == find(v)) {
sum++;
U[sum] = u;
if (!vis[u]) key[++sumk] = u;
V[sum] = v;
if (!vis[v]) key[++sumk] = v;
vis[u] = vis[v] = true;
} //利用并查集判断那些边是非树边
else {
addroad(u, v, ++cnt), addroad(v, u, ++cnt);
fa[find(v)][0] = fa[u][0];
}
}
build(1, 0);
sort(key + 1, key + sumk + 1, cmp);
cnt = 0, stack[top = 1] = 1;
for (int i = 1; i <= n; i++) vis[i] = 0;
for (int i = 1; i <= sumk; i++) Insert(key[i]); //构建虚树
while (top > 0) link(stack[--top], stack[top]);
Count(1); //计算系数,并预处理每个节点不计算含有虚树的子树的 dp 值
for (int S = 0; S < (1 << sum); S++) {
for (int i = 1; i <= num; i++)
g[tree[i]][0] = f[tree[i]][0], g[tree[i]][1] = f[tree[i]][1]; //赋初值
for (int i = 1; i <= sum; i++) //枚举状态的相关赋值
if (S & (1 << (i - 1)))
g[U[i]][0] = 0, g[V[i]][1] = 0;
else
g[U[i]][1] = 0;
DP(1); // DP
ans = (ans + (g[1][0] + g[1][1]) % mod) % mod; //计算答案
}
cout << ans;
}