洛谷P4708 画画

Address

洛谷P4708

Problem

求 $n(n\le 50)$ 个点无标号的每个连通块都有欧拉回路的图的个数。
答案对 $998244353$ 取模。

Solution

• 每个连通块都有欧拉回路即为每个点的度数都为偶数。
• 为方便起见，先把无标号转成有标号。
• 定义两个图同构当且仅当存在一种点置换，使得其中一个图在点置换作用下得到的新图和另一个图的连边情况完全相同。
• 考虑 burnside 引理：
  $$\begin{array}{r}L=\frac{1}{|G|}\sum _{g\in G}|F_g|\end{array}$$
• 因为所有点置换得到的边置换也是一个群，且点置换和得到的边置换构成双射，所以我们可以通过枚举点置换来计算边置换下的不动点个数，且边置换下的不动点个数也恰好满足我们对图同构的定义。
• 此时群 $G$ 的大小为 $n!$，恰好对应所有的排列。
• 把某一种点置换 $g$ 分解成若干个轮换的乘积，注意到如果轮换大小构成的多重集相同，对答案产生的贡献也相同。
• 因此我们只需要枚举轮换大小构成的多重集，设 $H$ 表示给定轮换大小的多重集时不动点的个数，则：
  $$\begin{array}{rl}L& =\frac{1}{n!}\sum _{{}_{l_1+l_2+...+l_k=n}^{l_1\le l_2\le ...\le l_k}}\frac{n!\prod _{i=1}^n(l_i-1)!}{\prod _{i=1}^k{l}_i!\prod _{i=1}^n{c}_i!}H(l_1,l_2,...,l_k)\\ & =\sum _{{}_{l_1+l_2+...+l_k=n}^{l_1\le l_2\le ...\le l_k}}\frac{1}{\prod _{i=1}^k{l}_i\prod _{i=1}^n{c}_i!}H(l_1,l_2,...,l_k)\end{array}$$
• 第一行 $H$ 前面的系数表示轮换大小分别为 $l_1,l_2,...,l_k$ 的排列个数，其中 $c_i$ 表示 $l_1,l_2,...,l_k$ 中 $i$ 的出现次数。
• 具体地，排列个数的计算可以这样考虑：
  1. 枚举所有排列 （$n!$），先不考虑每个轮换内部的构成，即除以 $\prod _{i=1}^k{l}_i!$；
  2. 每个轮换可以看做一个有向环，$l_i$ 个点构成有向环的方案数是 $(l_i-1)!$，所以要乘以 $\prod _{i=1}^k(l_i-1)!$；
  3. 大小相同的轮换之间是无序的，所以要除以 $\prod _{i=1}^n{c}_i!$。
• 考虑怎样计算 $H(l_1,l_2,...,l_k)$。
• 对于第 $i$ 个轮换，轮换内距离相同的所有点对的连边情况相同，而距离共有 $\lfloor \frac{l_i}{2}\rfloor$ 种，总的连边情况共有 $2^{\lfloor \frac{l_i}{2}\rfloor }$ 种。
  • 若 $l_i$ 为奇数，固定距离 $x$ 时，每个点都恰好可以引出两条边，因此对于每一种连边情况都能保证轮换内每个点度数的奇偶性不变。
  • 若 $l_i$ 为偶数，
    • 当 $x<\frac{l_i}{2}$ 时，情况和 $l_i$ 为奇数相同。
    • 当 $x=\frac{l_i}{2}$ 时，每个点只能恰好引出一条边，因此每一种连边情况都恰好能使轮换内每个点度数的奇偶性改变。
• 考虑任意两个轮换 $i,j$ 之间的连边情况，枚举两个轮换上的点对 $(x,y)$，则将 $(x,y)$ 同时顺次移动得到的所有点对和 $(x,y)$ 的连边情况相同。
• 因此共有 $\frac{l_i{l}_j}{lcm(l_i,l_j)}=\gcd (l_i,l_j)$ 组点对，每组点对的连边情况相同，且对于第 $i$ 个轮换上的每一点都恰好可以引出 $e_1=\frac{l_j}{\gcd (l_i,l_j)}$ 条边，对于第 $j$ 个轮换上的每一点都恰好可以引出 $e_2=\frac{l_i}{\gcd (l_i,l_j)}$ 条边。
  • 若 $e_1$ 和 $e_2$ 都为偶数，任意一种连边情况都不会改变轮换 $i,j$ 上每个点度数的奇偶性；
  • 若 $e_1$ 和 $e_2$ 都为奇数，任意一种连边情况都恰好会使轮换 $i,j$ 上每个点度数的奇偶性改变；
  • 若 $e_1$、$e_2$ 中恰好有一个为奇数，任意一种连边情况都恰好会使某一个轮换上每个点度数的奇偶性改变。
• 经过这些讨论，我们发现所有能改变奇偶性的操作都是对于整个轮换，因此我们可以把每个轮换缩成一个点，先将不会影响奇偶性的操作的方案数乘到答案上，把问题简化为：

给定 $k$ 个点和若干条边，每个点的初始点权为 $0$，每个点 $x$ 可以有 $cnt{p}_x$ 次机会使点权异或 $1$，每条边 $(x,y)$ 可以有 $cnt{e}_{(x,y)}$ 次机会使 $x,y$ 两个端点的点权同时异或 $1$，询问使得每个点最终的点权仍然都为 $0$ 的方案数。

• 依次考虑每个连通块的方案，将答案累乘。
• 对于每个连通块，任意找出一棵 DFS树，注意到如果我们确定了所有非树边和点的方案，树边的方案是唯一确定的，并且存在合法的方案当且仅当单点的操作次数和为偶数。
• 证明：
  1. 单点的操作使得连通块中恰好有偶数个点权为 $1$的点；
  2. 非树边的操作不会改变连通块中点权为 $1$ 的点的个数的奇偶性；
  3. 从 DFS树 的叶子结点开始往上推出每条树边的状态，对一个点 $x$ 指向其父结点的边操作当且仅当 $x$ 的点权为 $1$，并且每次只能使点权为 $1$ 的点的个数减少 $2$ 或不变，因此树边的方案唯一确定且合法。
• 于是一个点数为 $s$ 的连通块的方案为 2 max ⁡ { ( ∑ c n t p x ) − 1 , 0 } + ( ∑ c n t e ( x , y ) ) − s + 1 \begin{aligned} 2^{\max\{(\sum cntp_x) - 1, 0\} + (\sum cnte_{(x, y)}) - s + 1}\end{aligned} 2max{(∑cntpx​)−1,0}+(∑cnte(x,y)​)−s+1​。
• 设 $p_n$ 表示 $n$ 的拆分数，时间复杂度 $\mathcal{O}(n^2{p}_n)$，可以通过。

Code

#include <bits/stdc++.h>

const int N = 55;
const int M = 125e3 + 5;
const int mod = 998244353;

int n, m, ans;
int fra[N], inv_fra[N], inv[N];
int ex[M], g[N][N], l[N], c[N];
int sze[N], fa[N], cnt_p[N], cnt_e[N];

template <class T>
inline T Max(T x, T y) {return x > y ? x : y;}

inline void add(int &x, int y)
{
	x += y;
	x >= mod ? x -= mod : 0;
}

inline void mul(int &x, int y)
{
	x = 1ll * x * y % mod;
}

inline int quick_pow(int x, int k)
{
	int res = 1;
	while (k)
	{
		if (k & 1)
			res = 1ll * res * x % mod;
		x = 1ll * x * x % mod;
		k >>= 1;
	}
	return res;
}

inline int ufs_find(int x)
{
	return fa[x] == x ? x : fa[x] = ufs_find(fa[x]);
}

inline void ufs_merge(int x, int y, int e)
{
	int tx = ufs_find(x),
		ty = ufs_find(y);
	if (tx != ty)
	{
		if (sze[tx] > sze[ty])
			std::swap(tx, ty);
		fa[tx] = ty;
		sze[ty] += sze[tx];
		cnt_p[ty] += cnt_p[tx];
		cnt_e[ty] += cnt_e[tx] + e;
	}
	else
		cnt_e[ty] += e;
}

inline void solve(int k)
{
	int res = 1;
	for (int i = 1; i <= k; ++i)
		mul(res, inv[l[i]]);
	for (int i = 1; i <= n; ++i)
		mul(res, inv_fra[c[i]]);
	for (int i = 1; i <= k; ++i)
	{
		fa[i] = i;
		cnt_e[i] = 0;
		cnt_p[i] = 0;
		sze[i] = 1;
	}
	for (int i = 1; i <= k; ++i)
	{
		if (!(l[i] & 1))
			++cnt_p[i];
		mul(res, ex[l[i] - 1 >> 1]);
	}
	for (int i = 1; i < k; ++i)
		for (int j = i + 1; j <= k; ++j)
		{
			int e = g[l[i]][l[j]];
			bool e1 = (l[j] / e) & 1,
				 e2 = (l[i] / e) & 1;
			if (e1 && e2)
				ufs_merge(i, j, e);
			else if (e1)
				cnt_p[ufs_find(i)] += e;
			else if (e2)
				cnt_p[ufs_find(j)] += e;
			else 
				mul(res, ex[e]);
		}
	for (int i = 1; i <= k; ++i)
		if (ufs_find(i) == i)
			mul(res, ex[Max(0, cnt_p[i] - 1) + cnt_e[i] - sze[i] + 1]);
	add(ans, res);
}

inline void dfs(int k, int s, int t)
{
	if (!s)
		return solve(k - 1);
	for (int i = t; i <= s; ++i)
	{
		l[k] = i;
		++c[i];
		dfs(k + 1, s - i, i);
		--c[i];
	}
}

int main()
{
	scanf("%d", &n);
	fra[0] = 1;
	for (int i = 1; i <= n; ++i)
		fra[i] = 1ll * fra[i - 1] * i % mod;
	inv_fra[n] = quick_pow(fra[n], mod - 2);
	for (int i = n; i >= 1; --i)
		inv_fra[i - 1] = 1ll * inv_fra[i] * i % mod;
	inv[0] = inv[1] = 1;
	for (int i = 2; i <= n; ++i)
		inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
	ex[0] = 1;
	for (int i = 1, im = n * n * n; i <= im; ++i)
		add(ex[i] = ex[i - 1], ex[i - 1]);
	for (int i = 1; i <= n; ++i)
		for (int j = 1; j <= n; ++j)
			g[i][j] = std::__gcd(i, j);
	dfs(1, n, 1);
	printf("%d\n", ans);
}