P6329 【模板】点分树 | 震波【动态点分治】详解

传送门
给定一个无根树，求距离某点不大于$k$的所有点的权值和
支持单点修改

分析

动态点分治，点分治是主要思想
假如说，上面的询问操作只有一次
我们一次$dfs$就能求解到答案
但是我们有多次，且要支持修改。

高效利用树性质

这里我们知道，dfs每次都是重新算（真·暴力），能不能利用树的性质进行高效计算呢？
思考这一个问题
如果要求$x$的答案，假设$z$对$x$有贡献，
也就是说 $x\sim z$ 的距离$dis(x,z)<=k$，

• $z$ 如果是在 $x$ 的子树内，将$x$的子树用$vector$存起来，按距离排序，二分就能找到所有的$z$的个数，能想到这一步应该是没问题的
• 如果$z$不在子树内，看下面分析

此时如果另一个点$y$，$z$ 对 $y$也有贡献
此时$dis(y,z)<=k$
假设$y$ 为 $x$的父亲，父节点，($x$往根方向的节点)
对于不在$x$子树内的点，只要找在$y$子树中，小于等于 $k-dis(x,y)$的点有多少个，因为（$x$到$y$一段距离，$y$到$z$一段距离，这两段距离之和要小于$k$），再减去我$x$算过的点即可，这只是在$y$子树中的，继续考虑答案还可能在上面其它的子树中，所以要遍历它的所有父亲，去找所有父亲子树的答案，记得容斥
这里建议随便画个无根树看一下，理解起来应该不算太难，理解后看下面

对于一个随机化的无根树的结构（随机也就是树高$logn$），纸上随便画一棵二叉树，上面的解法是很优的
因为我们只要，每次去找$logn$个父亲，在父亲子树中找到一些点，经过简单的容斥，我们就能在接近$(logn{)}^2$的时间内得到答案

算法优化

但是树是可以容易构造出来卡这个算法的，因为不随机情况下，这个算法能退化到每次查询都是 $n$ 的复杂度（退化成链的情况）
那么，我们如何采用这个思路，但是将复杂度降下去呢？

这里我们弱化父亲的概念！ 这个很重要
我们为什么上面的算法一定要实用到父亲节点呢？
因为我能通过我到父亲节点的距离进一步得到，不在我子树的所有满足条件的所有点的答案。

那么我们是否能够这样构造一些集合，也能够让我得到所有满足条件的答案呢？

我们通过点分治的启发，注意这里只是启发，两者之间有区别
点分治通过子树分治的时候找重心来降低复杂度
我们这里就借用重心来构造集合，一个重心的定义是集合里面重心到其它任意点的距离最大值最小。一个重心管辖了一个点集。
正是这个性质，导致一个点最多有$logn$个父亲节点（注意，这里的父亲节点是重心父亲节点，在划分重心的时候是先由一个重心到它子树的重心的，这些重心形成了一颗树，理解一下）
那么，我们就能够利用这个性质来优化上面那个容易被卡的算法了，让每次最差的复杂度从$nlogn$ 达到惊人的 $(logn{)}^2$
这正是动态点分治的由来，借鉴了点分治的思想（找重心）

代码

//P6329-solve
/*
  @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("P6329_1.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++;
}

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

void dfs1(int u, int from) {
	parent[u] = from;
	dep[u] = dep[from] + 1;
	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);
		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) == son[u] || v == parent[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 = parent[top[x]];
	}
	return dep[x] < dep[y] ? x : y;
}

int dis(int x, int y) {
	int lca = LCA(x, y);
	return dep[x] + dep[y] - 2 * dep[lca];
}

int maxx[MAX_N];
bool vis[MAX_N];

void root(int u, int from, int& rt, int sum) {
	sz[u] = 1;
	maxx[u] = 0;
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from || vis[v]) continue;
		root(v, u, rt, sum);
		sz[u] += sz[v];
		maxx[u] = max(maxx[u], sz[v]);
	}
	maxx[u] = max(maxx[u], sum - sz[u]);
	if (maxx[u] < maxx[rt]) {
		rt = u;
	}
}

int dsz[MAX_N];
int father[MAX_N];

void divide(int u, int sum) {
	vis[u] = 1;
	dsz[u] = sum;
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if (vis[v=edge[i].to]) continue;
		int rt = 0;
		int vsz = sz[v] < sz[u] ? sz[v] : sum - sz[u];
		root(v, u, rt, vsz);
		father[rt] = u;
		divide(rt, vsz);
	}
}

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

int mk() {
	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 query(int rt, int l, int r, int x, int y) {
	if (!rt) return 0;
	if (x <= l && r <= y) {
		return tr[rt].k;
	}
	int mid = l + ((r-l)>>1);
	if (y <= mid) return query(tr[rt].l, l, mid, x, y);
	if (x  > mid) return query(tr[rt].r, mid+1, r, x, y);
	return query(tr[rt].l, l, mid, x, y) + query(tr[rt].r, mid+1, r, x, y);
}

int A[MAX_N], B[MAX_N];

void modify(int x, int k) {
	for (int i = x; i; i = father[i]) {
		update(A[i], 1, dsz[i] + 1, dis(x, i) + 1, k);
		if (father[i]) update(B[i], 1, dsz[father[i]] + 1, dis(x, father[i])+1, k);
	}
}

int ask(int x, int k) {
	int res = 0;
	int pre = 0;
	for (int i = x; i; pre = i, i = father[i]) {
		int d = dis(x, i);
		if (d > k) continue;
		res += query(A[i], 1, dsz[i] + 1, 1, k - d + 1);
		if (pre) res -= query(B[pre], 1, dsz[i] + 1, 1, k - d + 1);
	}
	return res;
}

int arr[MAX_N];

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

void solve(){
	init();
	sc("%d%d", &N, &M);
	for (int i = 1; i <= N; ++i) {
		sc("%d", &arr[i]);
	}
	int u, v;
	
	for (int i = 1; i < N; ++i) {
		cin >> u >> v;
		addEdge(u, v);
	}
	
	dfs1(1, 0);
	dfs2(1, 1);
	int rt = 0;
	maxx[0] = 1e8;
	root(1, 0, rt, N);
	divide(rt, N);

	for (int i = 1; i <= N; ++i) {
		modify(i, arr[i]);
	}
	
	int opt, x, y, k;
	int pre = 0;
	for (int i = 1; i <= M; ++i) {
		sc("%d", &opt);
		if (opt == 1) {
			sc("%d%d", &x, &y);
			x ^= pre, y ^= pre;
			modify(x, y - arr[x]);
			arr[x] = y;
		} else {
			sc("%d%d", &x, &k);
			x ^= pre, k ^= pre;
			pre = ask(x, k);
			pr("%d\n", pre);
		}
	}
}

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

	return AC;
}