BZOJ3572: [Hnoi2014]世界树-CSDN博客

BZOJ3572: [Hnoi2014]世界树

Description

世界树是一棵无比巨大的树，它伸出的枝干构成了整个世界。在这里，生存着各种各样的种族和生灵，他们共同信奉着绝对公正公平的女神艾莉森，在他们的信条里，公平是使世界树能够生生不息、持续运转的根本基石。
世界树的形态可以用一个数学模型来描述：世界树中有n个种族，种族的编号分别从1到n，分别生活在编号为1到n的聚居地上，种族的编号与其聚居地的编号相同。

有的聚居地之间有双向的道路相连，道路的长度为1。

保证连接的方式会形成一棵树结构，即所有的聚居地之间可以互相到达，并且不会出现环。

定义两个聚居地之间的距离为连接他们的道路的长度；例如，若聚居地a和b之间有道路，b和c之间有道路，因为每条道路长度为1而且又不可能出现环，所卧a与c之间的距离为2。
出于对公平的考虑，第i年，世界树的国王需要授权m[i]个种族的聚居地为临时议事处。

对于某个种族x（x为种族的编号），如果距离该种族最近的临时议事处为y（y为议事处所在聚居地的编号），则种族x将接受y议事处的管辖（如果有多个临时议事处到该聚居地的距离一样，则y为其中编号最小的临时议事处）。
现在国王想知道，在q年的时间里，每一年完成授权后，当年每个临时议事处将会管理多少个种族（议事处所在的聚居地也将接受该议事处管理）。

现在这个任务交给了以智慧著称的灵长类的你：程序猿。请帮国王完成这个任务吧。

Input

第一行为一个正整数n，表示世界树中种族的个数。
接下来n-l行，每行两个正整数x，y，表示x聚居地与y聚居地之间有一条长度为1的双向道路。

接下来一行为一个正整数q，表示国王询问的年数。
接下来q块，每块两行：
第i块的第一行为1个正整数m[i]，表示第i年授权的临时议事处的个数。
第i块的第二行为m[i]个正整数h[l]、h[2]、…、h[m[i]]，表示被授权为临时议事处的聚居地编号（保证互不相同）。

Output

输出包含q行，第i行为m[i]个整数，该行的第j(j=1，2…，，m[i])个数表示第i年被授权的聚居地h[j]的临时议事处管理的种族个数。

Sample Input

10
2 1
3 2
4 3
5 4
6 1
7 3
8 3
9 4
10 1
5
2
6 1
5
2 7 3 6 9
1
8
4
8 7 10 3
5
2 9 3 5 8

Sample Output

1 9
3 1 4 1 1
10
1 1 3 5
4 1 3 1 1

HINT

N<=300000, q<=300000,m[1]+m[2]+…+m[q]<=300000

题解Here!

这个题一看就知道要虚树。。。

为什么？

题目的数据范围$\sum_{i=1}^qm[i]$就已经提示我们要从$m$下手。。。

不知道虚树的可以看这里：

虚树学习笔记

$PS$：请确保自身的$DP$水平足够之后再阅读以下部分。。。

这题是一道不错的虚树练手题，就是——细节太多了。。。

根据虚树的套路，我们还是从一次询问开始。

一个非常暴力的思想就是：对于每个特殊的点，枚举所有非特殊点，搞出$LCA$，求出距离，并且更新答案。

这个方法的复杂度是惊人的$O(\sum_{i=1}^qm[i]n\log_2n)$。

于是你有了$30$分。。。

开始优化：

我们要求的是每个点离他最近的询问点。

但是我们发现这是一个比较烦人的树形$DP$。
因为存在特殊点控制其兄弟节点的情况！

这个$DP$要扫两遍：

向下做一遍计算出如果只看子树内，每个点被哪个点所控制；

再向上做一遍计算出如果只看子树外，每个点被哪个点所控制；

这两种情况取最小值即可。

说起来容易做起来难啊。。。

但是这也不行啊。

于是拿出虚树。

首先对于关键点构建出虚树，边权为两端的深度差。

设$colour[x]$表示$x$点受哪个节点的控制，$dp[x]$表示$x$和$colour[x]$的距离。

然后分类讨论：

对于特殊点：显然$colour[x]=x,dp[x]=0$。
对于非特殊点：和上面的$DP$一样扫两遍，先求出儿子对父亲的影响，再求父亲对儿子的影响。

但是我们怎么计算答案呢？

我们分开考虑每个点对于所在集合的贡献。

设$num[x]$表示$x$控制的点的个数。

初值就是$num[x]=size[x]$，也就是字树大小。

而$x$对$colour[x]$的贡献就是：

$$num[x]-\sum_{y\in \text{虚树中}son_x}num[y]+\text{能控制的点的个数}$$

然后是在$DP$时对一条虚树边（即原树一条链）的讨论：

两端在同一集合：我们可以让父亲控制链上的所有点，那么$num[fa]-=size[son]$。
两端在不同集合：那么链上一定存在某个点将整条链分成两个集合。

　　　　而这个点一定是最中间某个点。

　　　　注意这里的链在原树中可能接着许多其他子树，因此我们要倍增求。
　　　　至于距离的一半怎么求。。。还是看代码吧。。。这个要画个图感性理解一下。

　　　　假设找到的点是$u$，那么$num[fa]-=size[u],num[son]+=size[u]-size[son]$。

最后别忘了把根节点贡献也算进去。

这个题就没了。

记得数组要清零啥的细节问题。

附代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#define MAXN 300010
using namespace std;
int n,m,q,c=1,d=1,e=1;
int head_a[MAXN],head_b[MAXN],deep[MAXN],son[MAXN],size[MAXN],fa[MAXN][20],id[MAXN],top[MAXN];
int h[MAXN],que[MAXN],dp[MAXN],colour[MAXN],num[MAXN],ans[MAXN];
int top_stack,stack[MAXN];
bool special[MAXN];
struct Tree{
	int next,to;
}a[MAXN<<1];
struct New_Tree{
	int next,to,w;
}b[MAXN<<1];
inline int read(){
	int date=0,w=1;char c=0;
	while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
	while(c>='0'&&c<='9'){date=date*10+c-'0';c=getchar();}
	return date*w;
}
inline bool cmp(const int &p,const int &q){
	return id[p]<id[q];
}
inline void add_a(int x,int y){
	a[c].to=y;a[c].next=head_a[x];head_a[x]=c++;
	a[c].to=x;a[c].next=head_a[y];head_a[y]=c++;
}
inline void add_b(int u,int v,int w){
	b[e].to=v;b[e].w=w;b[e].next=head_b[u];head_b[u]=e++;
}
void dfs1(int rt){
	son[rt]=0;size[rt]=1;
	for(int i=head_a[rt];i;i=a[i].next){
		int will=a[i].to;
		if(!deep[will]){
			deep[will]=deep[rt]+1;
			fa[will][0]=rt;
			for(int j=1;j<=19;j++)fa[will][j]=fa[fa[will][j-1]][j-1];
			dfs1(will);
			size[rt]+=size[will];
			if(size[will]>size[son[rt]])son[rt]=will;
		}
	}
}
void dfs2(int rt,int f){
	id[rt]=d++;top[rt]=f;
	if(son[rt])dfs2(son[rt],f);
	for(int i=head_a[rt];i;i=a[i].next){
		int will=a[i].to;
		if(will!=son[rt]&&will!=fa[rt][0])dfs2(will,will);
	}
}
int find(int x,int dis){
	for(int i=19;i>=0&&deep[x]>dis;i--)if(deep[fa[x][i]]>=dis)x=fa[x][i];
	return x;
}
int LCA(int x,int y){
	while(top[x]!=top[y]){
		if(deep[top[x]]<deep[top[y]])swap(x,y);
		x=fa[top[x]][0];
	}
	if(deep[x]>deep[y])swap(x,y);
	return x;
}
void rebuild(){
	int x,dis,lca;
	sort(h+1,h+m+1,cmp);
	top_stack=1;
	stack[top_stack]=1;
	for(int i=1;i<=m;i++){
		x=h[i];
		if(x==1)continue;
		lca=LCA(x,stack[top_stack]);
		while(top_stack>1&&deep[stack[top_stack-1]]>deep[lca]){
			dis=deep[stack[top_stack]]-deep[stack[top_stack-1]];
			add_b(stack[top_stack-1],stack[top_stack],dis);
			stack[top_stack--]=0;
		}
		if(deep[lca]<deep[stack[top_stack]]){
			dis=deep[stack[top_stack]]-deep[lca];
			add_b(lca,stack[top_stack],dis);
			stack[top_stack--]=0;
		}
		if(deep[lca]>deep[stack[top_stack]])stack[++top_stack]=lca;
		stack[++top_stack]=x;
	}
	while(top_stack>1){
		dis=deep[stack[top_stack]]-deep[stack[top_stack-1]];
		add_b(stack[top_stack-1],stack[top_stack],dis);
		stack[top_stack--]=0;
	}
}
void dfs3(int rt){
	int will;
	num[rt]=size[rt];
	if(special[rt]){
		dp[rt]=0;
		colour[rt]=rt;
	}
	else dp[rt]=(1<<30);
	for(int i=head_b[rt];i;i=b[i].next){
		will=b[i].to;
		dfs3(will);
		if(dp[rt]>dp[will]+b[i].w||(dp[rt]==dp[will]+b[i].w&&colour[rt]>colour[will])){
			dp[rt]=dp[will]+b[i].w;
			colour[rt]=colour[will];
		}
	}
}
void dfs4(int rt){
	int will;
	for(int i=head_b[rt];i;i=b[i].next){
		will=b[i].to;
		if(dp[will]>dp[rt]+b[i].w||(dp[will]==dp[rt]+b[i].w&&colour[rt]<colour[will])){
			dp[will]=dp[rt]+b[i].w;
			colour[will]=colour[rt];
		}
		dfs4(will);
		if(colour[rt]==colour[will])num[rt]-=size[will];
		else{
			int dis=dp[rt]+dp[will]+deep[will]-deep[rt]-1,u;
			int k=dis/2-dp[will];
			u=find(will,deep[will]-k);
			if((dis&1)&&colour[rt]>colour[will]&&k>=0)u=fa[u][0];
			num[will]+=size[u]-size[will];
			num[rt]-=size[u];
		}
		ans[colour[will]]+=num[will];
	}
	if(rt==1)ans[colour[rt]]+=num[rt];
}
void clean(int rt){
	for(int i=head_b[rt];i;i=b[i].next)clean(b[i].to);
	head_b[rt]=colour[rt]=0;special[rt]=false;
}
void work(){
	while(q--){
		m=read();
		for(int i=1;i<=m;i++){
			h[i]=que[i]=read();
			ans[h[i]]=0;
			special[h[i]]=true;
		}
		rebuild();
		dfs3(1);
		dfs4(1);
		for(int i=1;i<=m;i++)printf("%d ",ans[que[i]]);
		printf("\n");
		e=1;
		clean(1);
	}
}
void init(){
	int x,y;
	n=read();
	for(int i=1;i<n;i++){
		x=read();y=read();
		add_a(x,y);
	}
	q=read();
	deep[1]=1;
	dfs1(1);
	dfs2(1,1);
}
int main(){
	init();
	work();
	return 0;
}

转载于:https://www.cnblogs.com/Yangrui-Blog/p/10585757.html