DSU——树上的文艺的暴力

Description

一个有根树，以1为根。多次询问，每次询问u的k级后代有多少个。

Input

第一行两个数N,M表示树的大小和询问个数
之后N-1行每行两个数a b表示a和b之间有一条边
之后M行每行两个数u,k表示一个询问，问u的k级后代有多少个

Output

输出M行，代表每个询问的答案

Sample Input

7 1

2 1

3 1

4 2

5 2

6 3

7 3

1 2

Sample Output

4

Hint

N<=300000, M<=300000

首先想n^2暴力，对于每一次询问，我们将会遍历一遍x的子树统计答案，之后再删除答案继续下一个问题。

然后我们发现，这样做一个节点会被统计、删除多次，浪费资源。这样我们试着能否不删除只统计？答案是不可能完全做到。

是的，我们试着对整棵树进行询问，由于是自底向上的，一个节点完全可以继承它子树的所有信息。但是这样的话，在统计其他子树时会与其冲突，因此我们选择的那个继承信息点要最后做。

那么如何选点呢？选重儿子。那么重儿子只会插入不会删除，由于一个点u到根有不超过logn条轻链，因此u会被插入删除logn次，总时间复杂度nlogn。

ps：这些所谓的启发式合并，只不过是在暴力的基础上优化了一下操作顺序，从n->logn，真是优秀~ ~

#include<bits/stdc++.h>
using namespace std;
const int Maxn=300005;
struct Edge{
	int cnt,h[Maxn],to[Maxn*2],next[Maxn*2];
	inline void add(int x,int y){
		next[++cnt]=h[x];to[cnt]=y;h[x]=cnt;
	}
}e;
#define to e.to[p]
struct Query{
	int t,k;
};vector<Query>vec[Maxn];
int dep[Maxn],siz[Maxn],son[Maxn];
int sum[Maxn],ans[Maxn];
void getson(int x,int fa,int Dep){
	siz[x]=1;dep[x]=Dep;
	for(int p=e.h[x];p;p=e.next[p])if(to^fa){
		getson(to,x,Dep+1);
		siz[x]+=siz[to];
		if(siz[to]>siz[son[x]])son[x]=to;
	}
}
void update(int x,int fa,int v){
	sum[dep[x]]+=v;
	for(int p=e.h[x];p;p=e.next[p])
		if(to^fa)update(to,x,v);
}
void dsu(int x,int fa){
	for(int p=e.h[x];p;p=e.next[p])
		if((to^fa)&&(to^son[x]))dsu(to,x),update(to,x,-1);//统计轻儿子 
	if(son[x])dsu(son[x],x);//统计重儿子，不删除 
	++sum[dep[x]];
	for(int p=e.h[x];p;p=e.next[p])
		if((to^fa)&&(to^son[x]))update(to,x,1);//加上轻儿子的贡献 
	for(int i=0;i<vec[x].size();++i)
		ans[vec[x][i].t]=sum[dep[x]+vec[x][i].k];
}
int main(){
	int n,m;scanf("%d%d",&n,&m);
	for(int i=1;i<n;++i){
		int x,y;scanf("%d%d",&x,&y);
		e.add(x,y),e.add(y,x);
	}
	getson(1,0,0);
	for(int i=1;i<=m;++i){
		int x,k;scanf("%d%d",&x,&k);
		vec[x].push_back((Query){i,k});
	}
	dsu(1,0);
	for(int i=1;i<=m;++i)printf("%d\n",ans[i]);
	return 0;
}