6438. 【GDOI2020模拟01.16】树上的鼠

题目

由于时间过于久远，而且题面本身也很清晰，所以就懒得另外叙述题目大意了（还有思考历程）。

正解

先考虑一条链的情况（长度为奇数，这里的长度是指点的数量）：
如果根在中点，先手无论移到哪里，后手都可以移到它的对称点去。
此时先手必败；
如果根不在中点，先手只要一开始移到中点，先手就赢了。
若长度为偶数，就将中间的两个点都看成中点。
先手第一步先移到离根比较远的那个中点上，以后就用一样的策略，每次到达对方的对称点。所以偶数时先手必胜。
然后这就可以推广到一棵树的情况。
可以发现先手必败的情况当且仅当满足以下条件：
树的直径的长度为奇数，并且根是直径的中点。

于是就可以DP了。设$f_{i,j}$表示$i$为根的子树，最深点的深度为$j$的方案数。
发现直接跑这个东西会挂。
改一下定义，将“最深点深度为$j$”改成“最深点深度不超过$j$”
考虑转移。直接转移还是会挂。
然后就有了这个套路做法：长链剖分，在转移的时候先继承重儿子的信息，再和轻儿子的信息合并。
信息合并的时候，共同有的长度（两块信息的最小长度）上的信息可以暴力做，至于剩下的信息，可以发现就是个区间乘的操作。
线段树？没必要，直接打标记就可以了（有点像差分）。
所以信息合并的时间复杂度是两块信息的最小长度。
合并一次相当于减少了一条重链，总的时间复杂度就是所有重链的长度加起来，也就是$O(n)$

至于统计答案，这是有点复杂的，不过可以推。
这里就不详细解释了。

---

代码

代码可能有点丑，因为信息很多都是用链表来存的。
常数也很大。

using namespace std;
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cassert>
#include <list>
#define N 1000010
#define ll long long
#define mo 998244353
ll qpow(ll x,int y){
	ll res=1;
	for (;y;y>>=1,x=x*x%mo)
		if (y&1)
			res=res*x%mo;
	return res;
}
int n;
struct EDGE{
	int to;
	EDGE *las;
} e[N*2];
int ne;
EDGE *last[N];
int q[N],fa[N],len[N],hs[N];
void getq(){
	int head=1,tail=1;
	q[1]=1;
	while (head<=tail){
		int x=q[head++];
		for (EDGE *ei=last[x];ei;ei=ei->las)
			if (ei->to!=fa[x]){
				fa[ei->to]=x;
				q[++tail]=ei->to;
			}
	}
}
list<ll> _data[N*2],*f[N],*tag[N];
int cnt;
void pd(list<ll>::iterator pf,list<ll>::iterator pt,list<ll> *t){
//	assert(pt!=t->end());
	ll tmp=*pt;
	*pf=*pf*tmp%mo;
	*pt=1;
	++pt;
	if (pt!=t->end())
		*pt=*pt*tmp%mo;
}
ll pro[N],tagp[N],sum[N],ans,all[N];
int main(){
//	freopen("in.txt","r",stdin);
//	freopen("out.txt","w",stdout);
	freopen("tree.in","r",stdin);
	freopen("tree.out","w",stdout);
	scanf("%d",&n);
	for (int i=1;i<n;++i){
		int u,v;
		scanf("%d%d",&u,&v);
		e[ne]={v,last[u]};
		last[u]=e+ne++;
		e[ne]={u,last[v]};
		last[v]=e+ne++;
	}
	getq();
	for (int i=n;i>=1;--i){
		int x=q[i];
		len[x]=1;
		for (EDGE *ei=last[x];ei;ei=ei->las)
			if (len[ei->to]+1>len[x])
				len[x]=len[ei->to]+1,hs[x]=ei->to;
	}
	for (int i=n;i>=2;--i){
		int x=q[i];
		if (!hs[x]){
			f[x]=&_data[++cnt];
			tag[x]=&_data[++cnt];
			f[x]->push_back(1);
			tag[x]->push_back(1);
			continue;
		}
		f[x]=f[hs[x]];
		f[x]->push_front(1);
		tag[x]=tag[hs[x]];
		tag[x]->push_front(1);
		for (EDGE *ei=last[x];ei;ei=ei->las)
			if (ei->to!=fa[x] && ei->to!=hs[x]){
				int y=ei->to;
				auto pfx=f[x]->begin(),pfy=f[y]->begin();
				auto ptx=tag[x]->begin(),pty=tag[y]->begin();
				ll sumx=0,sumy=1;
				pd(pfx,ptx,tag[x]);
				sumx+=*pfx;
				pfx++,ptx++;
				for (int k=1;k<=f[y]->size();++k,++pfx,++pfy,++ptx,++pty){
					pd(pfx,ptx,tag[x]),pd(pfy,pty,tag[y]);
					(sumx+=*pfx)%=mo,(sumy+=*pfy)%=mo;
					*pfx=((sumx*(*pfy)+sumy*(*pfx)-(*pfx)*(*pfy))%mo+mo)%mo;
				}
				if (pfx!=f[x]->end())
					(*ptx*=sumy)%=mo;
			}
	}
//	return 0;
	for (int i=1;i<=n;++i)
		pro[i]=1,tagp[i]=1;
	int maxd=0;
	for (EDGE *ei=last[1];ei;ei=ei->las){
		int y=ei->to;
		auto pfy=f[y]->begin(),pty=tag[y]->begin();
//		printf("%d ",y);
		for (int k=0;k<f[y]->size();++k,++pfy,++pty){
			pd(pfy,pty,tag[y]);
//			printf("%d ",*pfy);
		}
//		printf("\n");
		maxd=max(maxd,(int)f[y]->size());
		ll s=1;
		pfy=f[y]->begin();
		int k;
		for (k=1;pfy!=f[y]->end();++pfy,++k){
			s=(s+*pfy)%mo;
			pro[k]=pro[k]*s%mo;
			sum[k]=(sum[k]+*pfy*qpow((s-*pfy+mo)%mo,mo-2))%mo;
		}
		tagp[k]=tagp[k]*s%mo;
	}
	pro[0]=1;
	for (int i=1;i<=maxd;++i){
		pro[i]=pro[i]*tagp[i]%mo;
		tagp[i+1]=tagp[i+1]*tagp[i]%mo;
		tagp[i]=1;
		ans=(ans+pro[i]-pro[i-1]-sum[i]*pro[i-1]%mo+mo+mo)%mo;
	}
	ans+=1;
	for (int i=n;i>=1;--i){
		int x=q[i];
		all[x]=1;
		for (EDGE *ei=last[x];ei;ei=ei->las)
			if (ei->to!=fa[x])
				all[x]=all[x]*(all[ei->to]+1)%mo;
	}
	printf("%lld\n",(all[1]-ans+mo)%mo);
	return 0;
}

---

总结

做这种博弈题的时候，将当前局面转化成“位置一样，但选择变少”是一种比较妙的决策。
对于这种有关链的长度的信息的合并，可以考虑一下长链剖分。