【LOJ6240】仙人掌

最新推荐文章于 2023-09-28 20:56:49 发布

cz_xuyixuan

最新推荐文章于 2023-09-28 20:56:49 发布

阅读量1.1k

点赞数

CC 4.0 BY-SA版权

分类专栏：【类型】做题记录【OJ】LOJ 【算法】动态规划【数据结构】圆方树【算法】概率与期望【算法】组合数学

本文链接：https://blog.youkuaiyun.com/qq_39972971/article/details/89283070

【类型】做题记录同时被 3 个专栏收录

767 篇文章

订阅专栏

【算法】动态规划

239 篇文章

订阅专栏

【OJ】LOJ

123 篇文章

订阅专栏

该博客详细介绍了如何解决LOJ6240仙人掌问题，通过思路要点和数学期望计算每个点被选中时连通块操作次数，并在给定仙人掌为树的情况下简化概率计算。博主提出建立圆方树来优化算法，通过动态规划求解特定的E(xi)，最后实现O(N^3)的时间复杂度解决方案。

【题目链接】

点击打开链接

【思路要点】

记 $x_i$ 表示点 $i$ 被选中时，点 $i$ 所在的连通块共被操作了多少次，则有
$E(Ans)=E(\sum_{i=1}^{N} x_i)=\sum_{i=1}^{N} E(x_i)$
考虑计算 $x_i$ ，记 $P_{i,j}$ 表示在点 $j$ 被选中之前 $i$ 与 $j$ 始终连通的概率，则有
$E(x_i)=\sum_{j=1}^{N}P_{i,j}$
若给定的仙人掌是一棵树，那么记 $i$ 到 $j$ 路径上的点数为 $dist_{i,j}$ ，有 $P_{i,j}=\frac{1}{dist_{i,j}}$ 。
建立仙人掌的圆方树，那么 $i$ 到 $j$ 路径上经过的圆点不能比 $j$ 先被选中，且经过的每一个环由必经点分割而成的两部分不能均有点比 $j$ 先被选中。
记 $i$ 到 $j$ 路径上走过环的总点数为 $c n t$ ；在这些点中选出一个大小为 $x$ 的集合，使得删去集合中的点后 $i$ 到 $j$ 依然连通的方案数为 $dp_x$ 。考虑枚举 $j$ 被选中之前先被选中的点数 $k$ ，则有 $P_{i,j}=\sum_{k=0}^{cnt-1}\frac{1}{k+1}\times\frac{dp_k}{\binom{cnt}{k}}$
在仙人掌的圆方树上进行上述 $d p$ ，可以在 $O(N^2)$ 的时间内得出特定的 $E(x_i)$ 。
时间复杂度 $O(N^3)$ 。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 405;
const int MAXP = 805;
const int P = 998244353;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
int n, m, tot, ans, size[MAXN], rnk[MAXN][MAXN];
int timer, dfn[MAXN], low[MAXN], dp[MAXN][MAXN];
int binom[MAXN][MAXN], invb[MAXN][MAXN];
int top, Stack[MAXN], inv[MAXN];
vector <int> a[MAXN], t[MAXP];
void update(int &x, int y) {
	x += y;
	if (x >= P) x -= P;
}
int power(int x, int y) {
	if (y == 0) return 1;
	int tmp = power(x, y / 2);
	if (y % 2 == 0) return 1ll * tmp * tmp % P;
	else return 1ll * tmp * tmp % P * x % P;
}
void work(int pos, int fa, int cnt) {
	if (pos <= n) {
		for (int i = 0; i <= cnt; i++)
			update(ans, 1ll * dp[pos][i] * invb[cnt + 1][i] % P * inv[cnt + 1 - i] % P);
		for (auto x : t[pos])
			if (x != fa) work(x, pos, cnt);
	} else {
		int now = pos - n;
		static int tmp[MAXN][MAXN];
		memcpy(tmp[1], dp[fa], sizeof(dp[fa]));
		for (int i = 2; i <= size[now]; i++) {
			memset(tmp[i], 0, sizeof(tmp[i]));
			for (int j = 0; j <= cnt + i; j++) {
				tmp[i][j] = tmp[i - 1][j];
				if (j) update(tmp[i][j], tmp[i - 1][j - 1]);
			}
		}
		for (auto x : t[pos])
			if (x != fa) {
				int dis = abs(rnk[now][fa] - rnk[now][x]);
				for (int i = 0; i <= cnt + size[now] - 1; i++) {
					dp[x][i] = tmp[dis][i] + tmp[size[now] - dis][i] - dp[fa][i];
					if (dp[x][i] >= P) dp[x][i] -= P;
					else if (dp[x][i] < 0) dp[x][i] += P;
				}
			}
		for (auto x : t[pos])
			if (x != fa) work(x, pos, cnt + size[now] - 1);
	}
}
void dfs(int pos, int fa) {
	Stack[++top] = pos;
	low[pos] = dfn[pos] = ++timer;
	for (auto x : a[pos])
		if (!dfn[x]) {
			dfs(x, pos);
			chkmin(low[pos], low[x]);
			if (low[x] == dfn[pos]) {
				int tmp = 0; tot++;
				while (tmp != x) {
					tmp = Stack[top--];
					t[tot + n].push_back(tmp);
					t[tmp].push_back(tot + n);
					rnk[tot][tmp] = ++size[tot];
				}
				t[tot + n].push_back(pos);
				t[pos].push_back(tot + n);
				rnk[tot][pos] = ++size[tot];
			}
		} else chkmin(low[pos], dfn[x]);
}
int main() {
	read(n), read(m);
	for (int i = 0; i <= n; i++) {
		inv[i] = power(i, P - 2);
		binom[i][0] = invb[i][0] = 1;
		for (int j = 1; j <= i; j++) {
			binom[i][j] = (binom[i - 1][j] + binom[i - 1][j - 1]) % P;
			invb[i][j] = power(binom[i][j], P - 2);
		}
	}
	for (int i = 1; i <= m; i++) {
		int x, y; read(x), read(y);
		a[x].push_back(y);
		a[y].push_back(x);
	}
	dfs(1, 0);
	for (int i = 1; i <= n; i++) {
		memset(dp, 0, sizeof(dp));
		dp[i][0] = 1, work(i, 0, 0);
	}
	writeln(ans);
	return 0;
}