2021 ICPC沈阳 L.Perfect Matchings（树形dp+容斥原理）

题目描述

题目链接

题目大意

给你一个2n个点的完全图，从这个图里面删除2n−1条边，这些边形成一颗树，问剩下的图里面点进行完美匹配有多少种方案？

题目分析

$本题我们要对一个完全图选匹配边，而有一些边不能选择（2n-1条边），我们可以先算出包含这2n-1条边$$的所有方案，然后再用总的方案数减去这些方案就行了。$

$然后我们要求出包含树边的所有匹配方案，这个可以用树形dp来求：$

$状态表示：设f[u][i][0/1]表示以点u为根节点的子树中，有i个匹配，并且u节点是否参与匹配的方案数$

$状态转移：对于一个以u为根的节点，枚举其每个子节点v$
$此时有三种情况：$

$1、合并u与其子树v，并且不选u，f[u][i+j][0]+=f[u][i][0]\ast (f[v][j][0]+f[v][j][1])（选不选v对于该状态$$没有影响）$

$2、合并u与其子树v，选u，f[u][i+j][1]+=f[u][i][1]\ast (f[v][j][0]+f[v][j][1])$

$3、合并u与其子树v，并且加上一个u-v的匹配，f[u][i+j+1][1]+=f[u][i][0]\ast f[v][j][0]（因为要加一个u-v的新匹配，$$所以转移前的状态一定都是不带根节点的）$

$计算出所有的状态之后，再回来看怎么求出最终结果：$

$对于整个图来说，假设我们一定会选择x条树边，那么方案数就为f[1][x][0]+f[1][x][1]，而其余的边$$随便选，那么就有可能选到x，x+1，x+2，\dots \dots 条树边。$
$因为会出现这种选多了的情况，因此我们在求包含树边的情况时，就需要用到容斥原理。$

$我们先将求解过程进行拆分，枚举0-n，表示当前选择至少存在i条树边，方案数为x=f[1][i][0]+f[1][i][1]。$$这样就匹配了2\ast i个点，同时剩下了2\ast n-2\ast i个点任意选择，则有y钟方案数。当前情况的答案即为：x\ast y。$

$$补：y=\frac{C_{2n-2i}^{n-i}\ast (n-i)!}{2^{n-k}}$$
$将2n-2i个点分为两组:C_{2n-2i}^{n-i}$
$第一个点有n-i个选择，第二个点有n-i+1个选择\dots \dots ：(n-k)!$
$这样排会存在重复，每一条匹配边间两点都可以两两交换，因此会被多算2^{n-i}次$

$最后用容斥原理将所有情况加起来即可，然后如果有i条树边必选那么容斥系数就是(-1{)}^k（i=0时$$即为总的所有情况，i=1-n为存在树边的情况）。$

写这篇题解太不容易了，点个赞吧

代码如下

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <vector>
#include <algorithm>
#include <iomanip>
#define LL long long
#define ULL unsigned long long
#define PII pair<int,int>
#define PLL pair<LL,LL>
#define PDD pair<double,double>
#define x first
#define y second
using namespace std;
const int N=5e3+5,mod=998244353;
vector<int> h[N];
int fact[N],infact[N],p[N],sz[N];
LL f[N][N/2][2],g[N/2][2],ans;
int kmi(int a,int k)			//快速幂（用于求逆元）
{
	int res=1;
	while(k)
	{
		if(k&1) res=(LL)res*a%mod;
		a=(LL)a*a%mod;
		k>>=1;
	}
	return res;
}
void init(int n)	//预处理出阶乘、阶乘逆元、2的i次幂的逆元
{
	p[1]=kmi(2,mod-2);
	fact[0]=infact[0]=p[0]=1;
	for(int i=1;i<=n;i++)
	{
		fact[i]=(LL)fact[i-1]*i%mod;
		infact[i]=kmi(fact[i],mod-2);
		p[i]=(LL)p[i-1]*p[1]%mod;
	}
}
int C(int a,int b)		//求组合数C(a,b)
{
	if(b>a) return 0; 
	return (LL)fact[a]*infact[b]%mod*infact[a-b]%mod; 
}
void dfs(int u,int fa)		//dfs求树形dp
{
	sz[u]=f[u][0][0]=1;
	for(int v:h[u])
	{
		if(v==fa) continue;
		dfs(v,u);
		memset(g,0,sizeof g);		//定义一个g数组作为中间过度，防止重复计算
		for(int i=0;i<=sz[u]/2;i++)			//树上的边数为点数/2
			for(int j=0;j<=sz[v]/2;j++)		//合并v子树到u
			{	//三种状态转移
				g[i+j][0]=(g[i+j][0]+(LL)f[u][i][0]*(f[v][j][0]+f[v][j][1])%mod)%mod;
				g[i+j][1]=(g[i+j][1]+(LL)f[u][i][1]*(f[v][j][0]+f[v][j][1])%mod)%mod;
				g[i+j+1][1]=(g[i+j+1][1]+(LL)f[u][i][0]*f[v][j][0]%mod)%mod;
			}
		
		for(int i=0;i<=sz[u]/2+sz[v]/2+1;i++)		//将过渡数组转移回dp数组
			f[u][i][0]=g[i][0],f[u][i][1]=g[i][1];
		sz[u]+=sz[v];
	}
}
int main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);
	int n;
	cin>>n;
	init(N-1);
	for(int i=1;i<n*2;i++)			//建树
	{
		int u,v;
		cin>>u>>v;
		h[u].push_back(v);
		h[v].push_back(u);
	}
	dfs(1,-1);
	LL ans=0;
	for(int i=0;i<=n;i++)		//求出最少i条树边的方案数
	{
		LL x=(f[1][i][0]+f[1][i][1])%mod;		//树边的贡献
		int a=n-i;
		LL y=(LL)C(a*2,a)*fact[a]%mod*p[a]%mod;	//非树边的贡献
		if(i&1) ans=(ans-x*y%mod+mod)%mod;		//容斥原理合并
		else ans=(ans+x*y%mod)%mod;
	}
	cout<<ans<<endl;
	return 0;
}