树链剖分

入门博客推荐

树链剖分说白了就是把一棵树拆成若干个不相交的链，然后用一些数据结构去维护这些链。

因为通常的数据结构处理区间信息很容易，但处理树上的信息就显得捉襟见肘了。于是我们想到把树拍成一个区间用线段树去维护信息。（和树的dfs序是类似的原理）。

 树链剖分的几个常见应用：

①查询/修改树的子树的值：因为dfs的遍历顺序关系，每颗子树在线段树上必定是一段连续的区间，所以容易处理。

②查询/修改树两点路径间的值：因为每条重链是一段连续区间，那么两点间路径肯定是若干条链合起来得到，也就是线段树上的几段区间。

https://www.luogu.org/problem/P3384

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <vector>
#include <stack>
#include <map>
#include <string>
#define inf 0x3f3f3f3f
#define inf64 0x3f3f3f3f3f3f3f3f
using namespace std;
const int maxn = 2e5 + 10;

int f[maxn];//f 保存u的父亲节点
int dep[maxn];//dep保存节点u 的深度
int siz[maxn];//siz保存以u为根的子节点的个数
int son[maxn];//son 保存u的重儿子
int rk[maxn];//rk当前dfs序在树中所对应的节点
int top[maxn];// top保存当前结点所在链的顶端结点
int id[maxn];//dfs的执行顺序

int a[maxn];
int mod, n;
int sum[maxn * 4], lazy[maxn * 4];
//------------------线段树部分---------------//
void push_up(int id)
{
	sum[id] = (sum[id << 1] + sum[id << 1 | 1]) % mod;
	// printf("sum[%d]=%d sum[%d]=%d\n", id << 1, sum[id << 1], id << 1 | 1, sum[id << 1 | 1]);
	// printf("sum[%d]=%d\n", id, sum[id]);
}

void build(int id,int l,int r)
{
	lazy[id] = 0;
	if(l==r)
	{
		sum[id] = a[rk[l]] % mod;
		// printf("id=%d sum=%d\n", id, sum[id]);
		return;
	}
	int mid = (l + r) >> 1;
	build(id << 1, l, mid);
	build(id << 1 | 1, mid + 1, r);
	push_up(id);
}

void push_down(int id,int len1,int len2)
{
	if (lazy[id] == 0) return;
	sum[id << 1] += lazy[id] % mod * len1%mod;
	sum[id << 1] %= mod;

	lazy[id << 1] += lazy[id] % mod;
	lazy[id << 1] %= mod;

	sum[id << 1 | 1] += lazy[id] % mod * len2%mod;
	sum[id << 1 | 1] %= mod;

	lazy[id << 1 | 1] += lazy[id] % mod;
	lazy[id << 1 | 1] %= mod;

	lazy[id] = 0;
}

void update(int id,int l,int r,int x,int y,int val)
{
	// printf("id=%d l=%d r=%d x=%d y=%d val=%d\n", id, l, r, x, y, val);
	if(x<=l&&y>=r)
	{
		// printf("id=%d sum=%d\n", id, sum[id]);
		sum[id] += val * (r - l + 1) % mod;
		sum[id] %= mod;
		lazy[id] += val;
		lazy[id] %= mod;
		// printf("%d\n", sum[id]);
		return;
	}
	int mid = (l + r) >> 1;
	push_down(id, mid - l + 1, r - mid);
	if (x <= mid) update(id << 1, l, mid, x, y, val);
	if (y > mid) update(id << 1 | 1, mid + 1, r, x, y, val);
	push_up(id);
}

int query(int id,int l,int r,int x,int y)
{
	if (x <= l && y >= r) return sum[id];
	int mid = (l + r) >> 1, ans = 0;
	push_down(id, mid - l + 1, r - mid);
	if (x <= mid) ans = (ans + query(id << 1, l, mid, x, y)) % mod;
	if (y > mid) ans = (ans + query(id << 1 | 1, mid + 1, r, x, y)) % mod;
	return ans;
}



//------------------------树链剖分-------------------//
// int f[maxn];//f 保存u的父亲节点
// int dep[maxn];//dep保存节点u 的深度
// int siz[maxn];//siz保存以u为根的子节点的个数
// int son[maxn];//son 保存u的重儿子
// int rk[maxn];//rk当前dfs序在树中所对应的节点
// int top[maxn];// top保存当前结点所在链的顶端结点
// int id[maxn];//dfs的执行顺序
struct node
{
	int v, nxt;
	node(int v=0,int nxt=0):v(v),nxt(nxt){}
}ex[maxn];
int head[maxn], cnt = 0, tot;
void init()
{
	cnt = 0, tot = 0;
	memset(son, 0, sizeof(son));
	memset(head, -1, sizeof(head));
}
void add(int u,int v)
{
	ex[cnt] = node(v, head[u]);
	head[u] = cnt++;
	ex[cnt] = node(u, head[v]);
	head[v] = cnt++;
}


void dfs1(int u,int fa,int depth)
{
	f[u] = fa; dep[u] = depth; siz[u] = 1;
	for(int i=head[u];i!=-1;i=ex[i].nxt)
	{
		int v = ex[i].v;
		if (v == fa) continue;
		dfs1(v, u, depth + 1);
		siz[u] += siz[v];
		if (siz[v] > siz[son[u]]) son[u] = v;
	}
}

void dfs2(int u,int t)
{
	top[u] = t;
	id[u] = ++tot;//标记dfs序
	rk[tot] = u;//序号tot对应的结点u
	if (!son[u]) return;
	dfs2(son[u], t);
	/*我们选择优先进入重儿子来保证一条重链上各个节点dfs序连续，
	一个点和它的重儿子处于同一条重链，所以重儿子所在重链的顶端还是t*/
	for(int i=head[u];i!=-1;i=ex[i].nxt)
	{
		int v = ex[i].v;
		if (v != son[u] && v != f[u]) dfs2(v, v);//一个点位于轻链底端，那么它的top必然是它本身
	}
}

void update2(int x,int y,int z)//修改x到y路径的值 
{
	while(top[x]!=top[y])//不在同一条链上 
	{
		if (dep[top[x]] < dep[top[y]]) swap(x, y);//x为深度大的链 
		update(1, 1, n, id[top[x]], id[x], z);//x为深度大的链 
		x = f[top[x]];//深度大的向上跳 
	}
	if (dep[x] > dep[y]) swap(x, y); //这里x和y在同一条链 
	update(1, 1, n, id[x], id[y], z); //x和y这条链的更新 
}

int query2(int x,int y)
{
	int ret = 0;
	while(top[x]!=top[y])
	{
		if (dep[top[x]] < dep[top[y]]) swap(x, y);
		ret = (ret + query(1, 1, n, id[top[x]], id[x])) % mod;
		x = f[top[x]];
	}
	if (dep[x] > dep[y]) swap(x, y);
	ret = (ret + query(1, 1, n, id[x], id[y])) % mod;
	return ret;
}

//------------------树链剖分结束-------------------//


int main()
{
	init();
	int m, r;
	scanf("%d%d%d%d", &n, &m, &r, &mod);
	for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] %= mod;
	for (int i = 1; i < n; i++) {
		int u, v;
		scanf("%d%d", &u, &v);
		add(u, v);
	}
	dfs1(r, 0, 1), dfs2(r, r);
	build(1, 1, n);
	while(m--)
	{
		int opt, x, y, z;
		scanf("%d", &opt);
		if(opt==1)
		{
			scanf("%d%d%d", &x, &y, &z);
			update2(x,y,z);
		}
		if(opt==2)
		{
			scanf("%d%d", &x, &y);
			int ans = query2(x,y);
			printf("%d\n", ans);
		}
		if(opt==3)
		{
			scanf("%d%d", &x, &z);
			update(1, 1, n, id[x], id[x] + siz[x] - 1, z);
		}
		if(opt==4)
		{
			scanf("%d", &x);
			int ans = query(1, 1, n, id[x], id[x] + siz[x] - 1);
			printf("%d\n", ans);
		}
	}
}