P1600 [NOIP2016 提高组] 天天爱跑步

传送门

无根树，$N$个节点

给出 $M$​ 条链的起点 $s$​ 和 $t$​，起点 $s$​ 从$0$秒开始往 $t$​ 走，每秒走一个节点，每个节点有一个查看时间$w_i$，只有在当前查看时间看到

某个刚好走到当前节点 $p$ ，此时就算$s$造成一点贡献

求每个节点能够看到多少个

分析

这题和之前一道【雨天的尾巴】很像，都是对链进行某种类型的操作，然后统计这种类型的贡献

思路 【树上差分】+【线段树合并】

路径一般对 两个端点和$lca$ 进行操作，这里由于有时间的限制，速度一定，就能将时间转化为路程，在树上就是深度

先考虑，起始端点 $s$ 开始走，假设走到了$up$ 点，当 $dep[s]-w[up]=dep[up]$的时候，$up$ 这个点就能够看到了

但是树上的路径分两种，一种为

1. $s$ --> $lca$
2. $lca$ --> $t$

所以我们这里卡住了，分析不够完全，继续分类讨论

第一类路径，刚好是上面分析的，$dep[s]-w[up]=dep[up]$

第二类，假设从 $s$ 走到了 $down$ 点，分析深度的关系，$((dep[lca]+w[down])-dep[s])+dep[lca]=dep[down]$

• 第一个括号求的是，根到$lca$ 的长度加上走的那一段
• 第二个括号，由第一个括号减去起始的深度，得到的是$lca$ 到 $down$ 点的路径长度
• 接下来，再加上 $lca$ 那一段的长度，就等于，根到 $down$ 的长度

我们考虑的是某一个点能够看到多少，所以是对某点分析，将某点的信息移项到左边

• $dep[up]+w[up]=dep[s]$
• $dep[down]-w[down]=dep[lca]\ast 2-dep[t]$

可知，对于一条链，我们需要在链上维护两个深度值

线段树每个节点维护一个关于深度的桶，表示某个值有多少个东西存在

差分，在$s$​ -> $lca$​ 段，$s$​ 处将值为$dep[s]$​的个数$+1$​​，$lca$​ 的后一项，也就是$father[lca]$​ 处$-1$​

在$lca$ - > $t$ 段，$t$ 处将值为 $dep[lca]\ast 2-dep[t]$ 的个数$+1$，$lca$ 的后一项，也就是 $father[lca]$处$-1$

但是，聪明的你发现了，这是同一条链啊！假如我们在$lca$ 刚好能够观察到某条链的行动，势必会满足上面两个条件！

那么我们岂不是多算了？所以既然是差分，往后的影响肯定需要消除的，既然会重复，两个条件中便选一条在$lca$​处消除，

另一条在$father[lca]$ 处消除影响即可

对于最后的答案计算，就是线段树合并了。先将子树合并再算当前答案。

每次找满足两个条件的个数即可

细节：由于出现减法，线段树维护的桶会出现负数，所以整体桶值域往右移动$N$位，也就是将计算出来的每个数都加上$N$

代码

//P1600
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("P1600_17.in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 1e6+5;
const ll MOD = 1e9+7;
int N, M, K;


int head[MAX_N];
int tot = 0;
struct Edge {
	int to, nxt;
}edge[MAX_N];

void addEdge(int u, int v) {
	edge[tot].nxt = head[u];
	edge[tot].to = v;
	head[u] = tot++;
	edge[tot].nxt = head[v];
	edge[tot].to = u;
	head[v] = tot++;
	assert(tot+1<=MAX_N);
}

int arr[MAX_N];
int brr[MAX_N];


struct Tr {
	int k, l, r;
}tr[MAX_N<<4];
int indx = 0;
int root[MAX_N];

int mk() {
	assert(indx+1 <= (MAX_N<<4));
	return ++indx;
}

void push_up(int rt) {
	tr[rt].k = tr[tr[rt].l].k + tr[tr[rt].r].k;
}

void update(int &rt, int l, int r, int x, int k) {
	if (!rt) rt = mk();
	if (l == r) {
		tr[rt].k += k;
		return;
	}
	int mid = l + ((r-l)>>1);
	if (x <= mid) update(tr[rt].l, l, mid, x, k);
	if (x  > mid) update(tr[rt].r, mid+1, r, x, k);
	push_up(rt);
}


int merge(int x, int y, int l, int r) {
	if (!x || !y) return x | y;
	if (l == r) {
		tr[x].k += tr[y].k;
		return x;
	}
	int mid = l + ((r-l)>>1);
	tr[x].l = merge(tr[x].l, tr[y].l, l, mid);
	tr[x].r = merge(tr[x].r, tr[y].r, mid+1, r);
	push_up(x);
	return x;
}

int query(int rt, int l, int r, int x) {
	if (!rt) return 0;
	if (l == r) {
		return tr[rt].k;
	}
	int mid = l + ((r-l)>>1);
	if (x <= mid) return query(tr[rt].l, l, mid, x);
	if (x  > mid) return query(tr[rt].r, mid+1, r, x);
}

int sz[MAX_N];
int son[MAX_N];
int father[MAX_N];
int top[MAX_N];
int dep[MAX_N];

void dfs1(int u, int from, int d) {
	dep[u] = d;
	father[u] = from;
	son[u] = 0;
	sz[u] = 1;
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from) continue;
		dfs1(v, u, d+1);
		sz[u] += sz[v];
		if (sz[v] > sz[son[u]]) {
			son[u] = v;
		}
	}
}

void dfs2(int u, int tp) {
	top[u] = tp;
	if (son[u]) dfs2(son[u], tp);
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == father[u] || v == son[u]) continue;
		dfs2(v, v);
	}
}

int LCA(int x, int y) {
	while (top[x] != top[y]) {
		if(dep[top[x]] <= dep[top[y]]) swap(x, y);
		x = father[top[x]];
	}
	return dep[x] < dep[y] ? x : y;
}

int ans[MAX_N];

void dfs(int u) {
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == father[u]) continue;
		dfs(v);
		root[u] = merge(root[u], root[v], 1, N<<1);
	}
	ans[u] = query(root[u], 1, N<<1, N + dep[u] - arr[u]);
	// be care of "out of bounds"
	if (arr[u] && dep[u] + arr[u] <= N) ans[u] += query(root[u], 1, N<<1, N + dep[u] + arr[u]);
} 


void init() {
	memset(head, -1, sizeof head);
	tot = 0;
}

void solve(){
	init();
	sc("%d%d", &N, &M);
	int u, v;
	for (int i = 2; i <= N; ++i) {
		sc("%d%d", &u, &v);
		addEdge(u, v);
	}
	dfs1(1, 0, 1);
	dfs2(1, 1);
	
	for (int i = 1; i <= N; ++i) {
		sc("%d", &arr[i]);
	}
	int lca, p;
	for (int i = 1; i <= M; ++i) {
		sc("%d%d", &u, &v);
		lca = LCA(u, v);p = father[lca];
		update(root[u], 1, N<<1, N + dep[u], 1);
		update(root[v], 1, N<<1, N + dep[lca]*2-dep[u], 1);
		update(root[lca], 1, N<<1, N + dep[u], -1);
		update(root[p], 1, N<<1, N + dep[lca]*2-dep[u], -1);
// updates below also right!
// 		update(root[p], 1, N<<1, N + dep[u], -1);
// 		update(root[lca], 1, N<<1, N + dep[lca]*2-dep[u], -1);
	}
	dfs(1);
	for (int i = 1; i <= N; ++i) {
		pr("%d ", ans[i]);
	}
}

signed main()
{
	#ifndef ONLINE_JUDGE
	FILE_IN
	FILE_OUT
	#endif
	int T = 1;//cin >> T;
	while (T--) solve();

	return AC;
}