BZOJ3572 [Hnoi2014]世界树 【虚树 + 树形dp】

题目

世界树是一棵无比巨大的树，它伸出的枝干构成了整个世界。在这里，生存着各种各样的种族和生灵，他们共同信奉着绝对公正公平的女神艾莉森，在他们的信条里，公平是使世界树能够生生不息、持续运转的根本基石。

世界树的形态可以用一个数学模型来描述：世界树中有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年的时间里，每一年完成授权后，当年每个临时议事处将会管理多少个种族（议事处所在的聚居地也将接受该议事处管理）。 现在这个任务交给了以智慧著称的灵长类的你：程序猿。请帮国王完成这个任务吧。

输入格式

第一行为一个正整数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]]，表示被授权为临时议事处的聚居地编号（保证互不相同）。

输出格式

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

输入样例

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

输出样例

1 9

3 1 4 1 1

10

1 1 3 5

4 1 3 1 1

提示

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

题解

我代码能力真是太弱了

按套路先建虚树，然后在树上统计答案

过程比较烦：

①先求出虚树上每个点最近的议事处

两遍dfs即可，第一遍dfs用儿子最近的议事处更新父亲，第二遍dfs用父亲更新儿子，因为可能会出现儿子经过父亲到达另一个儿子的情况

②对于虚树上的每条边，计算贡献

由于边上有很多非虚树点，设边为(u,v)，其中u为父亲，那么用son[u]的子树大小减去v的子树大小就是之间的点数

如果u和v最近的议事处一样，那么这些点都加入那个议事处

如果不一样，那么在这条边上找出分界点，分别贡献到两个议事处

其中son[u]和分界点在树上倍增找出

③有些点既不在虚树边上，也不在虚树上

我们记g[u]为u点在已被计算的子树节点数量，那么剩余的节点数就可以加到u最近的议事处中

g[u]可以用②中son[u]的子树大小累加

然后就开码吧- -

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#define LL long long int
#define Redge(u) for (int k = h[u],to; k; k = ed[k].nxt)
#define REP(i,n) for (int i = 1; i <= (n); i++)
#define BUG(s,n) for (int i = 1; i <= (n); i++) cout<<s[i]<<' '; puts("");
using namespace std;
const int maxn = 300005,maxm = 600005,INF = 1000000000;
inline int read(){
	int out = 0,flag = 1; char c = getchar();
	while (c < 48 || c > 57){if (c == '-') flag = -1; c = getchar();}
	while (c >= 48 && c <= 57){out = (out << 3) + (out << 1) + c - 48; c = getchar();}
	return out * flag;
}
int hh[maxn],nn = 2;
int h[maxn],ne = 2;
struct EDGE{int from,to,nxt,w;}e[maxm],ed[maxm];
inline void add(int u,int v){
	e[nn] = (EDGE){u,v,hh[u],0}; hh[u] = nn++;
	e[nn] = (EDGE){v,u,hh[v],0}; hh[v] = nn++;
}
inline void build(int u,int v,int w){
	if (!w) return;
	ed[ne] = (EDGE){u,v,h[u],w}; h[u] = ne++;
	ed[ne] = (EDGE){v,u,h[v],w}; h[v] = ne++;
}
int n;
int fa[maxn][20],dep[maxn],dfn[maxn],siz[maxn],cnt;
void dfs(int u){
	dfn[u] = ++cnt;
	siz[u] = 1;
	for (int i = 1; i <= 19; i++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
	for (int k = hh[u],to; k; k = e[k].nxt)
		if ((to = e[k].to) != fa[u][0]){
			fa[to][0] = u; dep[to] = dep[u] + 1;
			dfs(to);
			siz[u] += siz[to];
		}
}
int lca(int u,int v){
	if (dep[u] < dep[v]) swap(u,v);
	for (int i = 0,d = dep[u] - dep[v]; (1 << i) <= d; i++)
		if ((1 << i) & d) u = fa[u][i];
	if (u == v) return u;
	for (int i = 19; i >= 0; i--)
		if (fa[u][i] != fa[v][i]){
			u = fa[u][i];
			v = fa[v][i];
		}
	return fa[u][0];
}
int K,a[maxn],st[maxn],top;
inline bool cmp(const int& a,const int& b){
	return dfn[a] < dfn[b];
}
void rebuild(){
	st[top = 1] = 1; ne = 2;
	sort(a + 1,a + 1 + K,cmp);
	for (int i = 1; i <= K; i++){
		int u = a[i],p = lca(u,st[top]);
		if (p == st[top]){st[++top] = u; continue;}
		else {
			while (true){
				if (dep[p] >= dep[st[top - 1]]){
					build(p,st[top],dep[st[top]] - dep[p]);
					top--;
					st[++top] = p;
					break;
				}
				build(st[top - 1],st[top],dep[st[top]] - dep[st[top - 1]]);
				top--;
			}
			st[++top] = u;
		}
	}
	while (top > 1)
		build(st[top - 1],st[top],dep[st[top]] - dep[st[top - 1]]),top--;
}
int id[maxn];
int nr[maxn],nd[maxn];
int ans[maxn],g[maxn];
int b[maxn],tot;
void dfs1(int u,int f){
	if (id[u]){
		nr[u] = u;
		nd[u] = 0;
	}else {
		nd[u] = INF;
	}
	Redge(u) if ((to = ed[k].to) != f){
		dfs1(to,u);
		if (nd[to] + ed[k].w < nd[u] || (nd[to] + ed[k].w == nd[u] && nr[to] < nr[u])){
			nd[u] = nd[to] + ed[k].w;
			nr[u] = nr[to];
		}
	}
}
void dfs2(int u,int f){
	Redge(u) if ((to = ed[k].to) != f){
		if (nd[u] + ed[k].w < nd[to] || (nd[u] + ed[k].w == nd[to] && nr[to] > nr[u])){
			nd[to] = nd[u] + ed[k].w;
			nr[to] = nr[u];
		}
		dfs2(to,u);
	}
	h[u] = 0; g[u] = 0;
	b[++tot] = u;
}
int up(int u,int dis){
	for (int i = 0; (1 << i) <= dis; i++)
		if ((1 << i) & dis) u = fa[u][i];
	return u;
}
void cal(){
	for (int k = 2; k < ne; k += 2){
		int x = ed[k].from,y = ed[k].to;
		int D = nd[x] - nd[y],nds = ed[k].w - 1;
		int s = up(y,nds);
		g[x] += siz[s];
		if (nr[x] == nr[y]){
			ans[id[nr[x]]] += siz[s] - siz[y];
			continue;
		}
		if (D >= nds){
			ans[id[nr[y]]] += siz[s] - siz[y];
		}else if (-D >= nds){
			ans[id[nr[x]]] += siz[s] - siz[y];
		}else {
			if (D > 0){
				int ns = nds - D;
				int dis = D + (ns >> 1) + ((ns & 1) && nr[y] < nr[x]);
				int mid = up(y,dis);
				ans[id[nr[y]]] += siz[mid] - siz[y];
				ans[id[nr[x]]] += siz[s] - siz[mid];
			}
			else {
				int ns = nds + D;
				int dis = (ns >> 1) + ((ns & 1) && nr[y] < nr[x]);
				int mid = up(y,dis);
				ans[id[nr[y]]] += siz[mid] - siz[y];
				ans[id[nr[x]]] += siz[s] - siz[mid];
			}
		}
	}
	for (int i = 1; i <= tot; i++)
		ans[id[nr[b[i]]]] += siz[b[i]] - g[b[i]];
}
void Solve(){
	tot = 0;
	dfs1(1,0);
	dfs2(1,0);
	cal();
	for (int i = 1; i <= K; i++) printf("%d ",ans[i]); puts("");
	for (int i = 1; i <= K; i++) id[a[i]] = ans[i] = 0;
}
int main(){
	n = read();
	for (int i = 1; i < n; i++) add(read(),read());
	dfs(1);
	int q = read();
	while (q--){
		K = read();
		for (int i = 1; i <= K; i++){
			a[i] = read();
			id[a[i]] = i;
		}
		rebuild();
		Solve();
	}
	return 0;
}