[九省联考2018]秘密袭击coat

CXLV.[九省联考2018]秘密袭击coat

首先先讲一种暴力但能过的方法。

很容易就会往每个值各被计算几次的方向去想。于是我们枚举每个节点，计算有多少种可能下该节点是目标节点。

为了避免相同的值的影响，我们在值相同的点间也决出一种顺序，即，若两个值相同的点在作比较，依照上文定下的那种顺序决定。

于是我们考虑从该枚举的点 $x$ 出发，遍历整棵子树同时DP。设 $f_{i,j}$ 表示 $i$ 子树中有 $j$ 个点的危险程度 $\geq d_x$。于是就直接背包转移就行了。

看上去复杂度是 $O(n^3)$，但是加上下述两个优化就可以过了：

1. 第二维最大只枚举到 $m$（这里的 $m$ 即题面中的 $k$，因为 $k$ 这个字母我们接下来还要用）

2. 第二维最大只枚举到子树大小 $sz$。

然后就过了，跑的还比正解都要快。

代码：

#include<bits/stdc++.h>
using namespace std;
const int mod=64123;
int n,m,W,d[2010],f[2010][2010],p[2010],q[2010],res,sz[2010];
vector<int>v[2010];
void dfs(int x,int fa,int lim){
	for(int i=0;i<=sz[x];i++)f[x][i]=0;
	f[x][sz[x]=(q[x]>=lim)]=1;
	for(auto y:v[x]){
		if(y==fa)continue;
		dfs(y,x,lim);
//		printf("%d:",x);for(int i=0;i<=m;i++)printf("%d ",f[x][i]);puts("");
//		printf("%d:",y);for(int i=0;i<=m;i++)printf("%d ",f[y][i]);puts("");
		for(int i=sz[x];i>=0;i--)for(int j=min(m-i,sz[y]);j>=0;j--)(f[x][i+j]+=1ll*f[x][i]*f[y][j]%mod)%=mod;
		sz[x]=min(sz[x]+sz[y],m);
//		printf("%d:",x);for(int i=0;i<=m;i++)printf("%d ",f[x][i]);puts("\n");
	}
}
int main(){
	scanf("%d%d%d",&n,&m,&W);
	for(int i=1;i<=n;i++)scanf("%d",&d[i]),p[i]=i;
	sort(p+1,p+n+1,[](int u,int v){return d[u]<d[v];});
	for(int i=1;i<=n;i++)q[p[i]]=i;
	for(int i=1,x,y;i<n;i++)scanf("%d%d",&x,&y),v[x].push_back(y),v[y].push_back(x);
	for(int i=1;i<=n;i++){
//		printf("%d\n",q[i]);
		if(q[i]>n-m+1)continue;
		dfs(i,0,q[i]);
		(res+=1ll*d[i]*f[i][m]%mod)%=mod;
	}
	printf("%d\n",res);
	return 0;
}

然后是正解。

我们要求 $\sum\limits_{\mathbb S\subseteq\mathbb T}\text{Kth of }\mathbb S$。

考虑枚举该 $\text{Kth}$ 的值为 $i$，则要求 $\sum\limits_{i=1}i\sum\limits_{\mathbb S\subseteq\mathbb T}[\text{Kth of }\mathbb S=i]$。

考虑让每个 $i$ 拆分成在所有的 $j\leq i$ 的位置上各被计算一次，则要求 $\sum\limits_{i=1}\sum\limits_{\mathbb S\subseteq\mathbb T}[\text{Kth of }\mathbb S\geq i]$。（这同时也是期望DP的经典套路）

考虑令 $cnt_i$ 表示 $\geq i$ 的数的总数。则要求 $\sum\limits_{i=1}\sum\limits_{\mathbb S\subseteq\mathbb T}[cnt_i\geq m]$。（注意这里的 $m$ 即为 $k$）

考虑对于每个连通块，在树上最高处计算它的贡献。设 $f_{i,j,k}$ 表示以 $i$ 为根的子树内，当前统计的是 $cnt_j$，且 $cnt_j=k$ 的方案数。转移是裸的背包卷积。

考虑如何求答案。因为我们是在最高处计算贡献，所以就要求 $\sum\limits_{i=1}^n\sum\limits_{j=1}^W\sum\limits_{k=m}^nf_{i,j,k}$。

因为我们是卷积，所以考虑FFT转移。又因为它一直在卷，所以我们干脆考虑压根不把它复原成系数式，就纯粹用点集表示。

更准确地说，因为 $f_{i,j}$ 的生成函数是 $\sum\limits_{k=1}^nf_{i,j,k}x^k$，一个 $n$ 次多项式，所以我们直接枚举 $x\in[1,n+1]$，然后分别求出这时的生成函数的值，最后拉格朗日插值一下就插回系数式了。

则，在合并父亲 $x$ 和儿子 $y$ 的 $f$ 数组时，因为是点集式，所以直接对应位置相乘就行了。

但是就算有了这么伟大的思路，我们算算复杂度，还是 $O(n^3)$ 的。有没有更棒的复杂度？

我们发现，最终要对所有 $x$ 求 $f$ 数组的和，倒不如在正常处理的过程中就顺便维护了。于是我们设 $g_{i,j}=\sum\limits_{k\in\text{subtree}_i}f_{k,j}$，则最终要求的就是 $\sum\limits_{i=m}^ng_{1,i}$。当然，依据分配律，我们还是可以直接一股脑求出 $\sum\limits_{i=1}^ng_{1,i}$，待插出系数式后再取 $\geq m$ 的项。

我们思考当合并 $f_{x,i}$ 与 $f_{y,i}$ 时会发生什么：

$f_{x,i}\rightarrow f_{x,i}\times(f_{y,i}+1)$（采用 $f_{y,i}$ 或不用）

$g_{x,i}\rightarrow g_{x,i}+g_{y,i}$

在全体结束后，再有 $g_{x,i}\rightarrow g_{x,i}+f_{x,i}$。

同时，为了便于合并，我们采用线段树合并来维护DP数组。（这种操作被称作整体DP）

我们考虑初始化，发现假如我们最外层枚举的点值是 $X$，则所有 $\forall i\leq d_x$，$f_{x,i}$ 在结束时都要乘上一个 $X$。

明显这个初始状态大体是区间的，非常适合线段树合并。

但是，就算这样，暴力合并的复杂度仍然 $O(n^3)$，必须考虑在区间上把它做掉。

于是，一个天才般的想法诞生了：

观察到每次的变换都是 $(f,g)\rightarrow(af+b,cf+d+g)$ 的形式。

而这个变换，可以用四元组 $(a,b,c,d)$ 唯一刻画。

同时，展开式子，就会发现这个变换具有结合律（虽然很遗憾的是，大部分情形下它不具有交换律）。

假如我们初始令 $b=f,d=g$ 的话，就会发现，做一次上述操作，它就自动帮你更新了 $f$ 与 $g$！

于是，我们把它看作区间的 tag，然后线段树合并就非常简单了。

同时，要注意的是，其单位元是 $(1,0,0,0)$。

我们来总结一下操作：当合并的时候，我们希望 $f_x\rightarrow f_x\times(f_y+1)$，而 $f_y+1$ 可以通过在遍历完 $y$ 的子树后打上全体 $+1$ 的 tag 解决，当然这里不需要额外增加其它的 tag，我们发现 $(1,1,0,0)$ 刚好胜任了这个操作。于是现在 $f_x\rightarrow f_{x}\times f_y$，$(f_y,0,0,0)$ 的 tag 即可（需要注意的是，$f_y$ 是线段树上 $y$ 处的 $b$）。$g_{x}\rightarrow g_x+g_y$，$(1,0,0,g_y)$ 即可，而 $g_y$ 则是 $d$。两个乘起来，就是使用 $(b,0,0,d)$。

最后合并 $f$ 与 $g$ 的时候，则要使用 $(1,0,1,0)$，意义通过展开即可得到就是将 $f$ 加到 $g$。而乘上 $X$ 的操作，使用 $(X,0,0,0)$ 即可。

需要注意的是，这里并不能标记永久化，主要是因为从四元组中抽出 $b$ 和 $d$ 的操作并非线性变换，不能打到 tag 上去，在线段树合并的时候要先一路下传到某一方已经没有叶子了再合并。

同时，使用 unsigned int 可以刚好把 64123 卡进一次乘法内不爆。

代码（一些比较疑惑的地方已经加了注释）：

#include<bits/stdc++.h>
using namespace std;
#define int unsigned int
const int mod=64123;
int n,m,W,d[2010],X,cnt,bin[5010000],tp,rt[2010],a[2010];
struct dat{//(f,g)->(af+b,cf+d+g)
	int a,b,c,d;
	dat(){a=1,b=c=d=0;}
	dat(int A,int B,int C,int D){a=A,b=B,c=C,d=D;}
	friend dat operator*(const dat&u,const dat&v){return dat((u.a*v.a)%mod,(u.b*v.a+v.b)%mod,(u.a*v.c+u.c)%mod,(u.b*v.c+u.d+v.d)%mod);}
	void operator*=(const dat&v){(*this)=(*this)*v;}
	void print()const{printf("(%u %u %u %u)\n",a,b,c,d);}
};
#define mid ((l+r)>>1)
int newnode(){return tp?bin[tp--]:++cnt;}
struct SegTree{
	int lson,rson;
	dat tag;
}seg[5010000];
void erase(int &x){if(x)seg[x].tag=dat(),erase(seg[x].lson),erase(seg[x].rson),bin[++tp]=x,x=0;}//erase all the subtree of x.
void pushdown(int x){
	if(!seg[x].lson)seg[x].lson=newnode();
	if(!seg[x].rson)seg[x].rson=newnode();
	seg[seg[x].lson].tag*=seg[x].tag,seg[seg[x].rson].tag*=seg[x].tag,seg[x].tag=dat();
}
void modify(int &x,int l,int r,int L,int R,dat val){
	if(l>R||r<L)return;
	if(!x)x=newnode();
	if(L<=l&&r<=R){seg[x].tag*=val;return;}
	pushdown(x),modify(seg[x].lson,l,mid,L,R,val),modify(seg[x].rson,mid+1,r,L,R,val);
}
void merge(int &x,int &y){
	if(!seg[x].lson&&!seg[x].rson)swap(x,y);
	if(!seg[y].lson&&!seg[y].rson){seg[x].tag*=dat(seg[y].tag.b,0,0,seg[y].tag.d);return;}
	pushdown(x),pushdown(y),merge(seg[x].lson,seg[y].lson),merge(seg[x].rson,seg[y].rson);
}
int query(int x,int l,int r){
	if(l==r)return seg[x].tag.d;
	pushdown(x);
	return (query(seg[x].lson,l,mid)+query(seg[x].rson,mid+1,r))%mod;
}
void iterate(int x,int l,int r){
	if(!x)return;
	printf("%u:[%u,%u]\n",x,l,r);seg[x].tag.print();
	iterate(seg[x].lson,l,mid),iterate(seg[x].rson,mid+1,r);
}
vector<int>v[2010];
void dfs(int x,int fa){
	modify(rt[x],1,W,1,W,dat(0,1,0,0));//set all into (0,1,0,0),which means only f=1.
	for(auto y:v[x])if(y!=fa)dfs(y,x),merge(rt[x],rt[y]),erase(rt[y]);
	modify(rt[x],1,W,1,d[x],dat(X,0,0,0));//those <=d[x] are multiplied by an X
	modify(rt[x],1,W,1,W,dat(1,1,1,0));
	//product of (1,0,1,0) and (1,1,0,0), first means add f to g(to calculate the real g), second means add 1 to f (stands for x itself not chosen at x's father)
}
int all[2010],tmp[2010],res;
int ksm(int x,int y=mod-2){int z=1;for(;y;y>>=1,x=x*x%mod)if(y&1)z=z*x%mod;return z;}
void Lagrange(){
	all[0]=1;
	for(int i=1;i<=n+1;i++)for(int j=i-1;j<=i;j--)(all[j+1]+=all[j])%=mod,(all[j]*=mod-i)%=mod;//note that j is unsigned!!!
//	for(int i=0;i<=n+1;i++)printf("%u ",all[i]);puts("");
	for(int i=1;i<=n+1;i++){
		int inv=ksm(mod-i),sum=0;
		for(int j=0;j<=n;j++)tmp[j]=all[j];
		for(int j=0;j<=n;j++)(tmp[j]*=inv)%=mod,(tmp[j+1]+=mod-tmp[j])%=mod;
//		if(i>=1410){for(int j=0;j<=n;j++)printf("%u ",tmp[j]);puts("");}
		for(int j=m;j<=n;j++)sum+=tmp[j];sum%=mod;
		for(int j=1;j<=n+1;j++)if(j!=i)(sum*=ksm((i-j+mod)%mod))%=mod;
		res+=sum*a[i]%mod;
	}
	res%=mod;
}
signed main(){
	scanf("%u%u%u",&n,&m,&W);
	for(int i=1;i<=n;i++)scanf("%u",&d[i]);
	for(int i=1,x,y;i<n;i++)scanf("%u%u",&x,&y),v[x].push_back(y),v[y].push_back(x);
	for(X=1;X<=n+1;X++)dfs(1,0),a[X]=query(rt[1],1,W),erase(rt[1]);
//	for(int i=1;i<=n+1;i++)printf("%u ",a[i]);puts("");
	Lagrange();printf("%u\n",res);
	return 0;
}