☆ [NOIp2016] 天天爱跑步 「树上差分」

题目类型：LCA+思维

传送门：>Here<

题意：给出一棵树，有\(M\)个人在这棵树上跑步。每个人都从自己的起点\(s[i]\)跑到终点\(t[i]\)，跑过一条边的时间为1秒。现在每个节点都有一个观察员，节点\(i\)上的观察员会在第\(W[i]\)秒进行观察，如果有\(x\)个人此时到达节点\(i\)，则这个观察员能够观察到\(x\)个人。问所有人跑步结束以后每个观察员可以观察到多少人

解题思路

这道题是公认所有\(NOIp\)中最难的一道题。但其实这道题的数据约定能够给我们很大的提示。

其实这道题的正解就是对各个部分分的方法的汇总和整合。因此我们先一一分析部分分如何拿

子任务一 暴力

由于\(N\)是\(1000\)，可以暴力模拟每个人的行动轨迹。求一个\(LCA\)暴力走一下就好了，没有思维难度。这个部分分能够首先让你熟悉题目的意思

子任务二 树退化为链

乍一看很简单，其实由于\(N=99994\)，也不是那么容易的。事实上，这一个部分分是整道题的精髓。

由于树已经退化为链，所以所有的路径要么从左往右，要么从右往左。我们可以记录一个桶\(b[x]\)。当我们从左往右扫到\(i\)时，\(b[x]\)表示以\(x\)为起点的所有路径中，能够一直延伸到\(i\)的路径数量。

记录这个有什么用呢？对于节点\(i\)，由于路径从左往右，所以如果想要一条路径在走到\(i\)的时候被观察到，那么这条路径的起点\(S\)一定满足：$$S=i-W[i]$$因此我们在考虑节点\(i\)时，只需要考虑以\(i-W[i]\)为起点的能够延伸到\(i\)的路径条数，这些路径一定能够在\(i\)点被观察到。因此我们需要统计的就是\(b[i-W[i]\)。那么从右往左的路径也类似，我们只需要统计\(b[i+W[i]]\)就可以了

那么如何维护\(b\)数组呢？我们可以首先记录每个点的起点个数，然后过了终点以后减去终点对应的那些起点。例如\(2\)开头只有\(3\)条路径：\((2,4) \ (2,3) \ (2,7)\)。我们扫描到\(2\)的时候让\(b[2]+=3\)，代表从\(2\)开始能够延伸到\(2\)的路径有\(3\)条。然而扫描到\(4\)的时候事实上只有\(2\)条路径满足了，因此在统计完\(3\)以后应当\(--b[2]\)，因为\((2,3)\)这条路径不可能延伸到\(4\)了。但是如果还存在一条路径\((1,3)\)呢？一个终点可能对应多个起点，所以我们需要用一个\(vector\)来维护每个终点对应的所有起点，在扫描到这个终点的时候扫一遍\(vector\)全部减掉

事实上，这就是差分。只不过普通差分只需要统计次数，而不会规定起点的深度。对于这个规定起点深度的问题，自然需要排除深度不正确的起点。所以才会需要用\(vector\)来记录

子任务三 \(S=1\)

我们发现，当\(S=1\)时，所有路径都是从根节点往下。这样的路径有什么特点？对于任意一个点\(u\)，由于它的路径一定是从根节点出发的，因此根节点到它的路径长度就是它的深度（根节点深度为0）。也就是说，这要满足\(dep[u]=W[u]\)，这个点就是能够被观察到的

那么到底会被观察到几次呢？这就取决于根节点到它有几条路径。或者用更便于统计的方法：\(u\)及它的子树内有多少个终点

子任务四 \(T=1\)

和前者反了一下，但也更巧妙。所有路径都是从下往上到根节点的

我们发现一条路径上的一个点如果要被观察到，首先应该满足$$dep[S]-dep[u]=W[u]$$移项我们发现，也就是$$dep[u]+W[u]=dep[S]$$也就是说我们需要找的答案等价于，在节点\(u\)及其子树中，有多少起点的深度为\(dep[u]+W[u]\)。

联系链状那一部分的做法，其实就是把一维的拓展为了树。由于所有路径都是向上的，也就等价于链状中所有路径都是从右向左的。我们记录一个桶\(b[x]\)表示深度为\(x\)的起点有多少个。因此我们还是一样，每遇到一个起点就++。特别的幸运的是，我们还不需要开一个\(vector\)，遇到终点就减去对应起点，因为终点一定是根节点。每一次统计的答案也就是\(b[dep[u]+W[u]]\)

但是有一个问题，我们这样的做法的正确性必须保证是在\(u\)的子树内。然而深度为\(x\)的起点有可能是之前在别的子树内统计的。怎么办？其实我们是从下往上走，也就是要在处理完\(u\)的全部子树以后才来处理\(u\)，于是我们其实只需要考虑新增加的部分就可以了。也就是在\(DFS\)下去之前先记录一个\(b[dep[u]+W[u]]\)存为\(tmp\)，在\(DFS\)结束以后的答案也就是\(b[dep[u]+W[u]]-tmp\)

附上如上子任务的代码 Code

正解

对于一般性的数据，所有路径一定是从下往上，经过\(LCA\)，再从上往下。而数据提示了我们\(S=1\)和\(T=1\)。这就是在暗示我们将路径分开来考虑！

因此，就像链的情况，正解就是需要判断起点深度的树上差分！

首先考虑所有的\((S,LCA)\)的路径。这些路径的特性与\(T=1\)的路径是一样的。都需要满足\(dep[u]+W[u]=dep[S]\)，唯一的不同就在于需要像链状一样，维护一个\(vector\)记录终点对应的起点，在过终点时减去即可。注意，这里的终点不是指\(T\)，而是\(LCA\)

最最难理解的就是\((LCA,T)\)这一部分了。我们依旧分析路劲的特征。发现被观察到的点一定满足$$W[u]+dep[T]-dep[u]=dis(S,T)$$移项得到$$dep[u]-W[u]=dep[T]-dis(S,T)$$。但是不像之前的\(dep[S]\)，这个\(dep[T]-dis(S,T)\)是在树上是没有实际意义的（一定要说有的话，那就是将向上的半截路径翻到上面去的深度）。

于是没有办法，我们需要类比\((S,LCA)\)部分的做法来处理这个部分。我们依然是从下往上做，与之前相反，每遇到一个\(T\)就代表着进入了一条新的路径，每遇到一个\(LCA\)就意味着离开了一条路径。并且我们每遇到一个终点，标记的不是对应起点，而是对应的\(dep[T]-dis(S,T)\)；每遇到一个\(LCA\)，减去的也是该路径对应的\(dep[T]-dis(S,T)\)。因此我们此时需要两个\(vector\)来存了

综上就是算法的基本思想。这里还有两个细节需要分析：

• 注意到\(dep[T]-dis(S,T)\)很有可能是个负数，这让\(c++\)开通特别麻烦。一个比较粗暴的方式就是全部一律右移\(MAXN\)

• 我们将一条路径剖为了\((S,LCA) 和 (LCA,T)\)。如果\(LCA\)恰好是能够被观察到的，不就重复统计了一遍？所以我们需要在最后结算的时候进行修改，如果当前路径的\(LCA\)会被看到，也就是满足$$dep[S]-dep[LCA]=W[LCA]$$那么就应当减去一个\(1\)了

Code

倍增的数组开太小了调试了近一个小时\(qwq\)。

/*By DennyQi 2018*/
#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
#define  r  read()
using namespace std;
typedef long long ll;
const int MAXN = 300010;
const int MAXM = 600010;
const int INF = 1061109567;
inline int Max(const int a, const int b){ return (a > b) ? a : b; }
inline int Min(const int a, const int b){ return (a < b) ? a : b; }
inline int read(){
    int x = 0; int w = 1; register char c = getchar();
    for(; c ^ '-' && (c < '0' || c > '9'); c = getchar());
    if(c == '-') w = -1, c = getchar();
    for(; c >= '0' && c <= '9'; c = getchar()) x = (x<<3) + (x<<1) + c - '0'; return x * w;
}
int N,M,x,y,len;
int first[MAXM],nxt[MAXM],to[MAXM],cnt;
int f[MAXN][25],dep[MAXN],W[MAXN],s[MAXN],t[MAXN],lca[MAXN],nums[MAXN],b[MAXN],bk[MAXN*2],ans[MAXN];
vector <int> S[MAXN];
vector <int> T1[MAXN], T2[MAXN];
inline void add(int u, int v){
	to[++cnt]=v, nxt[cnt]=first[u], first[u]=cnt;
}
void BZ_INIT(int u, int _f, int d){
	int v;
	dep[u] = d; f[u][0] = _f;
	for(int i = 1; (1 << i) <= d; ++i){
		f[u][i] = f[f[u][i-1]][i-1];
	}
	for(int i = first[u]; i; i = nxt[i]){
		if((v = to[i]) == _f) continue;
		BZ_INIT(v, u, d+1);
	}
}
inline int LCA(int a, int b){
	if(dep[a] < dep[b]) swap(a, b);
	for(int i = 20; i >= 0; --i){
		if(dep[a] - (1 << i) >= dep[b]) a = f[a][i];
	}
	if(a == b) return a;
	for(int i = 20; i >= 0; --i){
		if(f[a][i] == f[b][i]) continue;
		a = f[a][i], b = f[b][i];
	}
	return f[a][0];
}
void DFS1(int u, int _f){
	int v, tmp = b[dep[u] + W[u]];
	for(int i = first[u]; i; i = nxt[i]){
		if((v = to[i]) == _f) continue;
		DFS1(v, u);
	}
	b[dep[u]] += nums[u];
	ans[u] += b[dep[u] + W[u]] - tmp;
	for(int i = 0, sz = S[u].size(); i < sz; ++i){
		--b[S[u][i]];
	}
}
void DFS2(int u, int _f){
	int v, tmp = bk[dep[u] - W[u] + MAXN];
	for(int i = first[u]; i; i = nxt[i]){
		if((v = to[i]) == _f) continue;
		DFS2(v, u);
	}
	for(int i = 0, sz = T1[u].size(); i < sz; ++i){
		++bk[T1[u][i] + MAXN];
	}
	ans[u] += bk[dep[u] - W[u] + MAXN] - tmp;
	for(int i = 0, sz = T2[u].size(); i < sz; ++i){
		--bk[T2[u][i] + MAXN];
	}
}
int main(){
	N = r, M = r;
	for(int i = 1; i < N; ++i){
		x = r, y = r;
		add(x, y);
		add(y, x);
	}
	BZ_INIT(1, 0, 0);
	for(int i = 1; i <= N; ++i){
		W[i] = r;
	}
	for(int i = 1; i <= M; ++i){
		s[i] = r, t[i] = r;
		lca[i] = LCA(s[i], t[i]);
		len = dep[s[i]] + dep[t[i]] - 2 * dep[lca[i]];
		++nums[s[i]];
		S[lca[i]].push_back(dep[s[i]]);
		T1[t[i]].push_back(dep[t[i]] - len);
		T2[lca[i]].push_back(dep[t[i]] - len);
	}
	DFS1(1, 0);
	DFS2(1, 0);
	for(int i = 1; i <= M; ++i){
		if(dep[s[i]] - dep[lca[i]] == W[lca[i]]){
			--ans[lca[i]];
		}
	}
	for(int i = 1; i <= N; ++i){
		printf("%d ", ans[i]);
	}
	return 0;
}