P3258 [JLOI2014] 松鼠的新家

题目描述

松鼠的新家是一棵树，前几天刚刚装修了新家，新家有 n n n 个房间，并且有 n − 1 n-1 n−1 根树枝连接，每个房间都可以相互到达，且俩个房间之间的路线都是唯一的。天哪，他居然真的住在"树"上。

松鼠想邀请小熊维尼前来参观，并且还指定一份参观指南，他希望维尼能够按照他的指南顺序，先去 a 1 a_1 a1，再去 a 2 a_2 a2，......，最后到 a n a_n an，去参观新家。可是这样会导致重复走很多房间，懒惰的维尼不停地推辞。可是松鼠告诉他，每走到一个房间，他就可以从房间拿一块糖果吃。

维尼是个馋家伙，立马就答应了。现在松鼠希望知道为了保证维尼有糖果吃，他需要在每一个房间各放至少多少个糖果。

因为松鼠参观指南上的最后一个房间 a n a_n an 是餐厅，餐厅里他准备了丰盛的大餐，所以当维尼在参观的最后到达餐厅时就不需要再拿糖果吃了。

输入格式

第一行一个正整数 n n n，表示房间个数第二行 n n n 个正整数，依次描述 a 1 , a 2 , ⋯ , a n a_1, a_2,\cdots,a_n a1,a2,⋯,an。

接下来 n − 1 n-1 n−1 行，每行两个正整数 x , y x,y x,y，表示标号 x x x 和 y y y 的两个房间之间有树枝相连。

输出格式

一共 n n n 行，第 i i i 行输出标号为 i i i 的房间至少需要放多少个糖果，才能让维尼有糖果吃。

输入输出样例 #1

输入 #1

复制代码

输出 #1

复制代码

说明/提示

对于全部的数据，$2 \le n \le 3 \time算法思路

树结构构建：

使用邻接表存储树结构（add函数）。

节点数 n n n，访问序列存储在vis数组。

预处理阶段：

DFS遍历（dfs1函数）：从根节点（设为1）出发，计算每个节点的深度 d e de de和直接父节点 f a $i$ $0$ fa $i$ $0$ fa $i$ $0$ 。

倍增预处理：计算每个节点的 2 j 2^j 2j级祖先，用于LCA查询： f a $i$ $j$ = f a $f a \[ i$ $j - 1$ ] $j - 1$ ( 1 ≤ j ≤ 20 ) fa $i$ $j$ = fa $fa\[i$ $j-1$ ] $j-1$ \quad (1 \leq j \leq 20) fa $i$ $j$ =fa $fa\[i$ $j-1$ ] $j-1$ (1≤j≤20)

对数预处理：lg数组满足 2 lg $k$ − 1 ≤ k < 2 lg $k$ 2^{\text{lg} $k$ -1} \leq k < 2^{\text{lg} $k$ } 2lg $k$ −1≤k<2lg $k$ ，用于LCA跳跃优化。

LCA计算（lca函数）：

调整节点深度：若 d e $a$ < d e $b$ de $a$ < de $b$ de $a$ <de $b$ ，交换 a , b a,b a,b。

将较深节点上跳到与较浅节点同一深度：
a = f a $a$ $lg \[ d e \[ a$ − d e $b$ ] − 1 ] a = fa $a$ $\\text{lg}\[de\[a$ -de $b$ ]-1] a=fa $a$ $lg\[de\[a$ −de $b$ ]−1]

若此时 a = b a=b a=b，返回 a a a；否则同步上跳至LCA的子节点： a = f a $a$ $j$ , b = f a $b$ $j$ ( j 从大到小枚举 ) a = fa $a$ $j$ , \ b = fa $b$ $j$ \quad (j \text{从大到小枚举}) a=fa $a$ $j$ , b=fa $b$ $j$ (j从大到小枚举)

最终LCA为 f a $a$ $0$ fa $a$ $0$ fa $a$ $0$ 。

路径标记与调整：

初始化：a $vis\[1$ ] = 1。

遍历访问序列（ i i i从2到 n n n）：

对相邻节点对 ( v i s $i - 1$ , v i s $i$ ) (vis $i-1$ , vis $i$ ) (vis $i-1$ ,vis $i$ )：

差分标记：b $vis\[i-1$ ]++, b $vis\[i$ ]++。

计算LCA（设为 j s js js）：b $js$ --, b $fa\[js$ $0$ ]--。

调整：a $vis\[i-1$ ]--。

序列结束：a $vis\[n$ ]--。

差分数组累加（dfs2函数）：

从叶子向根DFS，将子节点的 b b b值累加到父节点： b $k$ = b $k$ + ∑ 子节点 t b $t$ b $k$ = b $k$ + \sum_{\text{子节点}t} b $t$ b $k$ =b $k$ +子节点t∑b $t$

最终答案：

对每个节点 i i i，输出 a $i$ + b $i$ a $i$ + b $i$ a $i$ +b $i$ 。

复杂度分析

时间：

DFS遍历： O ( n ) O(n) O(n)

倍增预处理： O ( n log ⁡ n ) O(n \log n) O(nlogn)
n − 1 n-1 n−1次LCA查询： O ( n log ⁡ n ) O(n \log n) O(nlogn)

差分累加： O ( n ) O(n) O(n)

总时间复杂度： O ( n log ⁡ n ) O(n \log n) O(nlogn)

空间： O ( n log ⁡ n ) O(n \log n) O(nlogn)（存储祖先数组）s 10^5$， 1 ≤ a i ≤ n 1 \le a_i \le n 1≤ai≤n。

详细代码

cpp 复制代码

#include<bits/stdc++.h>
using namespace std;
const int N=3e5+5;
int h[N],fa[N][25];
int vis[N],lg[N],de[N];
int a[N],b[N];
int m,n,i,j,x,y,tot;
struct node{
	int w,to,ne;
}wc[N*2];
void add(int a,int b)
{
	tot++;
	wc[tot].w=a;
	wc[tot].to=b;
	wc[tot].ne=h[a];
	h[a]=tot;
}
void dfs1(int k)
{
	int s=h[k];
	while(s!=0)
	{
		int t=wc[s].to;
		if(t!=fa[k][0])
		{
			fa[t][0]=k;
			de[t]=de[k]+1;
			dfs1(t);
		} 
		s=wc[s].ne;
	}
}
int lca(int a,int b)
{
	if(de[a]<de[b])
	{
		int t=a;
		a=b;
		b=t;
	}
	while(de[a]!=de[b])
	{
		int k=lg[de[a]-de[b]]-1;
		a=fa[a][k];
	}
	if(a==b) return a;
	else{
		for(j=lg[de[a]]-1;j>=0;j--)
		{
			if(fa[a][j]!=fa[b][j])
			{
				a=fa[a][j];
				b=fa[b][j];
			}
		}
	}
	return fa[a][0];
}
void dfs2(int k)
{
	int s=h[k];
	while(s!=0)
	{
		int t=wc[s].to;
		if(t!=fa[k][0]){dfs2(t);b[k]+=b[t];}
		s=wc[s].ne;
	}
}
int main()
{
	ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
	cin>>n;
	for(i=1;i<=n;i++)
		cin>>vis[i]; 
	for(i=1;i<=n-1;i++)
	{
		cin>>x>>y;
		add(x,y);
		add(y,x);
	}
	dfs1(1);
	for(j=1;j<=20;j++)
		for(i=1;i<=n;i++)
			fa[i][j]=fa[fa[i][j-1]][j-1];
	for(i=1;i<=n;i++)
		lg[i]=lg[i-1]+(1<<lg[i-1]==i?1:0);
	a[vis[1]]++;
	for(i=2;i<=n;i++)
	{
		int js=lca(vis[i],vis[i-1]);
		b[vis[i]]++;
		b[vis[i-1]]++;
		b[js]--;
		b[fa[js][0]]--;
		a[vis[i-1]]--;
	}
	a[vis[n]]--;
	dfs2(1);
	for(i=1;i<=n;i++)
		cout<<a[i]+b[i]<<endl;
	return 0;
}