【十二省联考2019】希望（长链剖分）（树形DP）（线性求逆元）（可回退化）

传送门

---

近年来std最反人类的题。

然而听说这是因为lca不知道在想什么专门写了个内存池管理

加上大量注释和空行， std上900行也不是不能理解。

选手命要没了

然而如果真的要喷这道题的话。。。

好像也无从喷起，毕竟出出来就是防AK的。

题解：

这道题有一个理论基础。针对树上连通块计数的容斥，我们考虑包含每个点的方案，减去包含每条边的方案，得到的就是不重不漏的方案数，证明可以考虑对于任意树上连通块，点数-边数=1。

这道题，对于一个点或边，方案数显然就是包含它的连通块数量的$k$次方。

那么现在需要考虑的就是怎么算包含一个点或边的连通块数量。

设$f[u][L]$表示只包含$u$和$u$子树内部的点，且最远点离$u$距离不超过$L$的连通块数量。

设$g[u][L]$表示只包含$u$和$u$子树外部的点，且最远点离$u$距离不超过$L$的连通块数量。

如果我们能够求出上面的DP数组，则答案为$$\sum _u(f[u][L]g[u][L]{)}^k-\sum _{f{a}_v=u}(f[v][L-1](g[v][L]-1){)}^k$$

现在我们有一个很显然的转移：

$$f[u][i]=\prod _{v\in Son(u)}(f[v][i-1]+1)$$
$$g[v][i]=1+g[u][i-1]\prod _{w\in Son(u),v!=w}(f[w][i-2]+1)$$

现在我们已经有一个$O(nL)$的暴力，注意这里有一个细节，就是转移$g$的时候，我们会用到$f$的积除掉某一个数，这个数可能是$0$。正确的做法是维护$f$的前缀积和后缀积。

设$mxdep[u]$表示$u$子树内的最大深度（自己深度为1），则对于$i\ge mxdep[u]$，根据定义$f[u][i]=f[u][mxdep[u]-1]$。

而对于$g$，由于会用到的只有$g[u][L]$，所以我们要求的是$g[u][L-mxdep[u]\cdots L]$

考虑用长链剖分优化转移。

$f$的转移很显然是一个naiive的长链剖分，随便搞就行了

对于$g$的转移，我们需要$f$的前后缀，按照处理$f$的倒序处理$g$，让$f$支持一下可回退化就行了。

注意到转移的时候只有后缀乘和全局加，直接维护一个标记$ax+b$表示为$x$的值的真实值是$ax+b$。后缀乘的时候暴力用逆元搞一下前缀然后全局乘就行了。后缀可能会出现乘0的情况，维护一个后缀赋值标记就行了，记录一下最靠前的进行了后缀乘$0$的位置是哪个，同时维护一下值。

注意到这里出现了暴力用逆元搞一下。

我们发现需要求逆元的只有$f[u][mxdep[u]-1]$。

如果不能快速搞定这个东西，这就成了复杂度瓶颈。。。

但是$f[u][mxdep[u]]$这个东西可以在开局用一次DP算出来。

那么我们直接套用求阶乘逆元的方式$O(n+\log p)$求一次逆元就行了。

---

代码：

#include<bits/stdc++.h>
#define ll long long
#define re register
#define gc get_char
#define cs const

namespace IO{
	inline char get_char(){
		static cs int Rlen=1<<22|1;
		static char buf[Rlen],*p1,*p2;
		return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,Rlen,stdin),p1==p2)?EOF:*p1++;
	}
	
	template<typename T>
	inline T get(){
		char c;T num=c^48;
		while(!isdigit(c=gc()));num=c^48;
		while(isdigit(c=gc()))num=(num+(num<<2)<<1)+(c^48);
		return num;
	}
	inline int gi(){return get<int>();}
}
using namespace IO;

using std::cerr;
using std::cout;

cs int mod=998244353,INF=0x3f3f3f3f;
inline int add(int a,int b){a+=b-mod;return a+(a>>31&mod);}
inline int dec(int a,int b){a-=b;return a+(a>>31&mod);}
inline int mul(int a,int b){ll r=(ll)a*b;return r>=mod?r%mod:r;} 
inline int power(int a,int b,int res=1){
	for(;b;b>>=1,a=mul(a,a))(b&1)&&(res=mul(res,a));
	return res;
}
inline void Inc(int &a,int b){a+=b-mod;a+=a>>31&mod;}
inline void Dec(int &a,int b){a-=b;a+=a>>31&mod;}
inline void Mul(int &a,int b){a=mul(a,b);}

cs int N=1e6+7;
int n,L;

std::vector<int> E[N],G[N];
inline void adde(int u,int v){
	E[u].push_back(v);
	E[v].push_back(u);
}

int mxdep[N],son[N],fl[N];
void dfs(int u,int p){
	fl[u]=1;mxdep[u]=1;
	for(int re v:E[u])if(v!=p){
		dfs(v,u);
		Mul(fl[u],fl[v]+1);
		if(mxdep[v]+1>mxdep[u]){
			son[u]=v;
			mxdep[u]=mxdep[v]+1;
		} 
	}
	for(int re v:E[u])if(v!=p&&v!=son[u])G[u].push_back(v);
}

int inv[N];
inline void init_inv(){
	static int val[N],prod[N];prod[0]=1;
	for(int re i=1;i<=n;++i){
		val[i]=add(fl[i],1);
		if(!val[i])val[i]=1;
		prod[i]=mul(prod[i-1],val[i]);
	}inv[n]=power(prod[n],mod-2);
	for(int re i=n-1;~i;--i)inv[i]=mul(inv[i+1],val[i+1]);
	for(int re i=1;i<=n;++i)Mul(inv[i],prod[i-1]);
}

int in[N],clk;
void dfs(int u){
	in[u]=++clk;
	if(son[u])dfs(son[u]);
	for(int re v:G[u])dfs(v);
}

namespace Back{
bool work;
int *st[N*12],pre[N*12],top;
inline void sign(int &x,int v){if(work){st[++top]=&x;pre[top]=x;}x=v;}
inline void back(int low){while(top>low){*st[top]=pre[top];--top;}}
}
using namespace Back;

struct Arr{
	int *h,siz,a,ia,b,lim,val;
	inline int operator[](int p){
		return add(mul(a,p<lim?h[std::min(siz,p)]:val),b);
	}
	inline void mult(int p,int v){
		if(p<0||p>siz)return ;
		sign(h[p],mul(dec(mul(v,add(mul(a,h[p]),b)),b),ia));
	}
	inline void set(int p){
		if(p<=siz){
			sign(lim,p);
			sign(val,mul(dec(0,b),ia));
		}
	}
	inline void set(int p,int v){
		if(p<0||p>siz)return ;
		h[p]=mul(dec(v,b),ia);
	}
}f[N],g[N];

int far[N],gar[N],tar[N];
int f1[N],f2[N],gl[N];
int tim[N];

void dfs1(int u){
	if(son[u]){
		dfs1(son[u]);
		f[u]=f[son[u]];
		--f[u].h;++f[u].siz;
		if(f[u].lim!=INF)++f[u].lim;
	}
	else f[u]=(Arr){far+in[u],0,1,1,0,INF,0};
	Inc(f[u].b,1);f[u].set(0,1);
	for(int re v:G[u])dfs1(v);
	for(int re v:G[u]){
		tim[v]=top;
		for(int re i=0;i<mxdep[v];++i)
		f[u].mult(i+1,f[v][i]+1);
		if(int t=add(fl[v],1)){
			for(int re i=0;i<=mxdep[v];++i)
			f[u].mult(i,inv[v]);
			Mul(f[u].a,t);
			Mul(f[u].ia,inv[v]);
			Mul(f[u].b,t);
		}else f[u].set(mxdep[v]+1);
	}
	f1[u]=f[u][L];
	f2[u]=f[u][L-1];
}

void dfs2(int u){
	std::reverse(G[u].begin(),G[u].end());
	int n=1;for(int re v:G[u])n=std::max(n,mxdep[v]);
	memset(tar,0,sizeof(int)*n);
	Arr tmp=(Arr){tar,n-1,1,1,1,INF,0};
	for(int re v:G[u]){
		int t=add(fl[v],1);
		if(t){
			Mul(f[u].a,inv[v]);
			Mul(f[u].ia,t);
			Mul(f[u].b,inv[v]);
		}
		back(tim[v]);
		g[v]=(Arr){gar+in[v],mxdep[v]-1,1,1,0,INF,0};
		for(int re i=0;i<mxdep[v];++i){
			int j=L+i-mxdep[v]+1;
			if(j<2){
				if(j==1)g[v].h[i]=1;
				continue;
			}
			g[v].h[i]=mul(g[u][j+mxdep[u]-2-L],mul(f[u][j-1],tmp[j-2]));
		}
		Inc(g[v].b,1);
		for(int re i=0;i<mxdep[v];++i)tmp.mult(i,f[v][i]+1);
		if(t){
			for(int re i=0;i<mxdep[v];++i)tmp.mult(i,inv[v]);
			Mul(tmp.a,t);
			Mul(tmp.ia,inv[v]);
			Mul(tmp.b,t);
		}
		else tmp.set(mxdep[v]);
	}
	gl[u]=g[u][mxdep[u]-1];
	if(son[u]){
		int s=son[u];g[s]=g[u];g[s].siz--;
		for(int re v:G[u]){
			for(int re i=0;i<mxdep[v];++i)g[s].mult(i+1+mxdep[s]-L,f[v][i]+1);
			int j=mxdep[v]+mxdep[s]-L;
			if(j<mxdep[s]-1){
				int t=add(fl[v],1);
				if(t){
					for(int re i=std::max(0,mxdep[s]-L-1);i<=j;++i)
					g[s].mult(i,inv[v]);
					Mul(g[s].a,t);
					Mul(g[s].ia,inv[v]);
					Mul(g[s].b,t);
				}
				else g[s].set(j+1);
			}
		}
		Inc(g[s].b,1);
		g[s].set(mxdep[s]-L-1,1);
		g[s].set(mxdep[s]-L,2);
	}
	for(int re v:G[u])dfs2(v);
	if(son[u])dfs2(son[u]);
}

signed main(){
#ifdef zxyoi
	freopen("hope.in","r",stdin);
#endif
	n=gi(),L=gi();int k=gi();
	if(!L)cout<<n<<"\n",exit(0);
	for(int re i=1;i<n;++i)adde(gi(),gi());
	dfs(1,0);init_inv();dfs(1);
	work=true;dfs1(1);
	g[1]=(Arr){gar+1,mxdep[1]-1,1,1,1,INF,0};
	work=false;dfs2(1);
	int ans=0;
	for(int re i=1;i<=n;++i)Inc(ans,power(mul(f1[i],gl[i]),k));
	for(int re i=2;i<=n;++i)Dec(ans,power(mul(f2[i],dec(gl[i],1)),k));
	cout<<ans<<"\n";
	return 0;
}