bzoj3572_hnoi2014 世界树

题目大意：给出一棵树，每次询问给出k[i]个点，如果点x离k[i]个点中的点j最近，那么称x被j管理，对于每次询问，给出k[i]个点每个点管理的点的数量（包括自己）。

保证所有询问k[i]之和不超过300000，n<=300000.

       首先对于所有询问的点构建一棵虚树（废话）..

       （其实虚树的特征看询问方式和数据范围的特点一般就能看出）。

       那么现在问题在于如何统计答案，我们先处理出对于每个虚树当中的点i，支配它的关键点是哪个（关键点指询问中给出的那些点），这个可以用儿子或者父亲节点来更新自己，这不是一次dfs能处理的，那就两次嘛。（设支配点i的关键点为belong[i]）

       然后，对于我们再遍历一遍虚树，统计答案如下：

       若当前点x为虚树的根，那么Ans[belong[x]]+=size[1]-size[x]，为什么呢？因为x之上的所有点都只能先走到x，再走到其他点，那么 belong[x]显然是对于那些点来说的最优点。

       若不是虚树的根（设Anc为当前点x在虚树中的父亲）：

       如果belong[Anc]=belong[x]，那么belong[x]对于这条路径上的所有点以及这条路径所衍生的所有子树都是最优解。

       否则我们找到中间的一个断点c，使得c及以下的点离belong[x]更近，c以上的点离belong[Anc]更近，累加答案即可

然而还没完，同之前根的情况，可能当前点x衍生出去的某些子树不在虚树中，但是必须累加到答案里，所以就直接把他们累加到Ans[belong[x]]中就可以了。

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <ctime>
#define inf 1e9
using namespace std;
struct node{int to;int next;int len;
};node edge[1000010],bian[1000010];
int All = 0,tot = 0,fir[300010],first[300010],size[3000010];
int in[300010],out[300010],f[300010][21],Ans[300010],k,len,top;
int stack[300010],list[600010],que[300010],tim,dep[300010];
int belong[300010],n,m,a,b,dis[300010],root;
bool mark[300010];
bool comp(const int &x,const int &y) {return in[x] < in[y];}
bool check(int x,int y) {
	return in[x] < in[y] && out[x] > out[y];
}
void add(int x,int y) {
	All ++;
	edge[All].to = y;
	edge[All].next = fir[x];
	fir[x] = All;
}
void inser(int x,int y,int z) {
	tot ++;
	bian[tot].to = y;
	bian[tot].next = first[x];
	bian[tot].len = z;
	first[x] = tot;
}
void dfs(int x,int Anc,int depth) {
	in[x] = ++ tim;
	dep[x] = depth;
	f[x][0] = Anc;
	size[x] = 1;
	for(int i = 1;i <= 20;i ++)
		f[x][i] = f[f[x][i - 1]][i - 1];
	for(int u = fir[x];u;u = edge[u].next)
		if(dep[edge[u].to] == 0)
			dfs(edge[u].to,x,depth + 1),size[x] += size[edge[u].to];
	out[x] = ++ tim;
}
int lca(int x,int y) {
	if(dep[x] < dep[y]) swap(x,y);
	for(int i = 20;i >= 0;i --)
		if(dep[f[x][i]] >= dep[y])
			x = f[x][i];
	if(x == y) return x;
	for(int i = 20;i >= 0;i --)
		if(f[x][i] != f[y][i])
			x = f[x][i],y = f[y][i];
	return f[x][0];
}
void work1(int x) {
	for(int u = first[x];u;u = bian[u].next)
		work1(bian[u].to);
	if(mark[x]) belong[x] = x,dis[x] = 0;
	else 
	{
		int ret = inf,pos = inf;
		for(int u = first[x];u;u = bian[u].next)
		{
			if(dis[bian[u].to] + bian[u].len < ret)
			{
				ret = dis[bian[u].to] + bian[u].len;
				pos = belong[bian[u].to];
			}
			else if(dis[bian[u].to] + bian[u].len == ret && belong[bian[u].to] < pos)
				pos = belong[bian[u].to];
		}
		belong[x] = pos;
		dis[x] = ret;
	}
}
void work2(int x,int pre,int Anc) {
	if(x != root)
	{
		if(dis[Anc] + pre < dis[x])
		{
			belong[x] = belong[Anc];
			dis[x] = dis[Anc] + pre;
		}
		else if(dis[Anc] + pre == dis[x] && belong[Anc] < belong[x])
			belong[x] = belong[Anc];
	}
	for(int u = first[x];u;u = bian[u].next)
		work2(bian[u].to,bian[u].len,x);
}
int Ask(int x,int y) {
	for(int i = 20;i >= 0;i --)
		if(dep[f[x][i]] > dep[y])
			x = f[x][i];
	return x;
}
void getans(int x,int Anc) {
	if(x == root) Ans[belong[x]] += size[1] - size[x];
	else 
	{
		int father = Ask(x,Anc);
		if(belong[x] == belong[Anc])
			Ans[belong[x]] += size[father] - size[x];
		else 
		{
			int Now = x,ret = 0;
			for(int i = 20;i >= 0;i --)
			{
				if(dep[f[Now][i]] >= dep[father])
				{
					if(dis[x] + (1 << i) + ret < dis[Anc] + dep[x] - dep[Anc] - (1 << i) - ret)
					{
						Now = f[Now][i],ret += (1 << i);
					}
					else if(dis[x] + (1 << i) + ret == dis[Anc] + dep[x] - dep[Anc] - (1 << i) - ret)
						if(belong[x] < belong[Anc])
							Now = f[Now][i],ret += (1 << i);
				}
			}
			Ans[belong[Anc]] += size[father] - size[Now];
			Ans[belong[x]] += size[Now] - size[x];
		}
	}
	int w = size[x];
	for(int u = first[x];u;u = bian[u].next)
	{
		w -= size[Ask(bian[u].to,x)];
		getans(bian[u].to,x);
	}
	Ans[belong[x]] += w;
}
int main() {
	scanf("%d",&n);
	for(int i = 1;i <= n - 1;i ++)
	{
		scanf("%d%d",&a,&b);
		add(a,b);
		add(b,a);
	}
	dfs(1,0,1);
	scanf("%d",&m);
	for(int i = 0;i <= 300000;i ++) belong[i] = dis[i] = inf;
	while(m --) 
	{
		scanf("%d",&k);len = k;top = 0;
		for(int i = 1;i <= k;i ++) scanf("%d",&list[i]);
		for(int i = 1;i <= k;i ++) que[i] = list[i];
		sort(list + 1,list + len + 1,comp);
		for(int i = 2;i <= k;i ++)
			list[ ++ len] = lca(list[i],list[i - 1]);
		sort(list + 1,list + len + 1,comp);
		len = unique(list + 1,list + len + 1) - list - 1;
		for(int i = 1;i <= len;i ++)
		{
			while(top > 0 && ! check(stack[top],list[i]))
				 top --;
			if(stack[top] == 0) root = list[i];
			else inser(stack[top],list[i],dep[list[i]] - dep[stack[top]]);
			stack[ ++ top] = list[i];
		}
		for(int i = 1;i <= k;i ++) mark[que[i]] = true;
		work1(root);
		work2(root,0,0);
		getans(root,0);
		for(int i = 1;i <= k;i ++) printf("%d ",Ans[que[i]]);
		tot = 0;printf("\n");
		for(int i = 1;i <= k;i ++) mark[que[i]] = false;
		for(int i = 1;i <= len;i ++) first[list[i]] = 0;
		for(int i = 1;i <= len;i ++) dis[list[i]] = inf;
		for(int i = 1;i <= len;i ++) belong[list[i]] = inf;
		for(int i = 1;i <= len;i ++) Ans[list[i]] = 0;
	}
	return 0;
}