【数据结构】轻重链剖分（总结）

​
很早就知道这个东西了，也只是知道（NOI 大纲上这玩意不属于提高级）。

然后题目4632逼着我去学树链剖分。

去 OI wiki 上看了一会，花了点时间对着把模板打了。

这个东西可以看作是 dfs 序的进阶玩法。

将树划分成若干条连续的链，它们在 dfs 序上对应的区间也是连续的。

于是上数据结构维护。

我们给出一些定义：

定义 重子节点 表示其子节点中子树最大的子结点。如果有多个子树最大的子结点，取其一。如果没有子节点，就无重子节点。

定义 轻子节点 表示剩余的所有子结点。

从这个结点到重子节点的边为 重边。

到其他轻子节点的边为 轻边。

若干条首尾衔接的重边构成 重链。

把落单的结点也当作重链，那么整棵树就被剖分成若干条重链。

可以发现，树上每个节点都属于且仅属于一条重链。

重链开头的结点不一定是重子节点（因为重边是对于每一个结点都有定义的）。

所有的重链将整棵树 完全剖分。

在剖分时 重边优先遍历，最后树的 DFN 序上，重链内的 DFN 序是连续的。按 DFN 排序后的序列即为剖分后的链。

一颗子树内的 DFN 序是连续的。

可以发现，当我们向下经过一条 轻边 时，所在子树的大小至少会除以二。

因此，对于树上的任意一条路径，把它拆分成从 lca 处分别向两边往下走，分别最多走 log 次，因此，树上的每条路径都可以被拆分成不超过 log 条重链。

对于树上路径（$u\to v$）的修改，我们参考倍增求 lca 的方法，每次选取 u,v 中深度较大的那个往上跳，遇到重链直接跳到重链顶部，轻边就暴力跳 father。

由此，我们得到了一个可以在 $O(lo{g}^{2}n)$ 的时间内对树的任意两点之间的路径和任意一点的子树进行修改、查询的数据结构。

树剖常数较小，大多数情况跑不满，可以放心食用。

模板题：

Luogu P3384
可以让你熟悉树链剖分的使用和各基本操作。

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define inf 0x3f3f3f3f
#define N 100005
int n, m, r, p;
int num[N];
int first[N << 1], Next[N << 1], to[N << 1], tot;
inline void add(int x, int y)
{
   
	Next[++tot] = first[x];
	first[x] = tot;
	to[tot] = y;
	return;
}
int fa[N], dep[N], size[N], hson[N];
void dfs1(int u)
{
   
	size[u] = 1;
	for(int i = first[u]; i; i = Next[i])
	{
   
		int v = to[i];
		if(dep[v])
		{
   
			continue;
		}
		fa[v] = u;
		dep[v] = dep[u] + 1;
		dfs1(v);
		size[u] += size[v];
		if(!hson[u] || (size[v] > size[hson[u]]))
		{
   
			hson[u] = v;
		}
	}
	return;
}
int top[N], dfn[N], rnk[N], sign;
void dfs2(int u, int fr)
{
   
	top[u] = fr;
	dfn[u] = ++sign;
	rnk[sign] = u;
	if(!hson[u])
	{
   
		return;
	}
	dfs2(hson[u], fr);
	for(int i = first[u]; i; i = Next[i])
	{
   
		int v = to[i];
		if(v == fa[u] || v == hson[u])
		{
   
			continue;
		}
		dfs2(v, v);
	}
	return;
}
class segment_tree
{
   
	private:
	struct node
	{
   
		int l, r, sum, tag;
	};
	node tree[N << 2];
	inline void pushup(int root)
	{
   
		tree[root].sum = (tree[root << 1].sum + tree[root << 1 | 1].sum) % p;
		return;
	}
	inline void addtag(int root, int v)
	{
   
		tree[root].tag += v;
		tree[root].tag %= p;
		tree[root].sum += ((tree[root].r - tree[root].l + 1) * v) % p;
		tree[root].sum %= p;
		return;
	}
	inline void pushdown(int root)
	{
   
		if(tree[root].tag)
		{
   
			addtag(root << 1, tree[root].tag);
			addtag(root << 1 | 1, tree[root].tag);
			tree[root].tag = 0;
		}
		return;
	}
	public:
	void build(int root, int l, int r)
	{
   
		tree[root].l = l;
		tree[root].r = r;
		if(l == r)
		{
   
			tree[root].sum = num[rnk[l]] % p;
			return;
		}
		int mid = (l + r) >> 1;
		build(root << 1, l, mid);
		build(root << 1 | 1, mid + 1, r);
		pushup(root);
		return;
	}
	void update(int root, int L, int R, int v)
	{
   
		if(L <= tree[root].l && tree[root].r <= R)
		{
   
			addtag(root, v);
			return;
		}
		pushdown(root);
		int mid = (tree[root].l + tree[root].r) >> 1;
		if(L <= mid)
		{
   
			update(root << 1, L, R, v);
		}
		if(mid < R)
		{
   
			update(root << 1 | 1, L, R, v);
		}
		pushup(root);
		return;
	}
	int querysum(int root, int L, int R)
	{
   
		if(L <= tree[root].l && tree[root].r <= R)
		{
   
			return tree[root].sum;
		}
		pushdown(root);
		int mid = (tree[root].l + tree[root].r) >> 1, ret = 0;
		if(L <= mid)
		{
   
			ret += querysum(root << 1, L, R);
			ret %= p;
		}
		if(mid < R)
		{
   
			ret += querysum(root << 1 | 1, L, R);
			ret %= p;
		}
		pushup(root);
		return ret;
	}
};
segment_tree T;
inline void addline(int x, int y, int v)
{
   
	v %= p;
	int fx = top[x], fy = top[y];
	while(fx != fy)
	{
   
		if(dep[fx] <= dep[fy])
		{
   
			T.update(1, dfn[fy], dfn[y], v);
			y = fa[fy];
		}
		else
		{
   
			T.update(1, dfn[fx], dfn[x], v);
			x = fa[fx];
		}
		fx = top[x];
		fy = top[y];
	}
	T.update(1, min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v);
	return;
}
inline int qsum(int x, int y)
{
   
	int ret = 0, fx = top[x], fy = top[y];
	while(fx != fy)
	{
   
		if(dep[fx] <= dep[fy])
		{
   
			ret += T.querysum(1, dfn[fy], dfn[y]);
			ret %= p;
			y = fa[fy];
		}
		else
		{
   
			ret += T.querysum(1, dfn[fx], dfn[x]);
			ret %= p;
			x = fa[fx];
		}
		fx = top[x];
		fy = top[y];
	}
	ret += T.querysum(1, min(dfn[x], dfn[y]), max(dfn[x], dfn[y]));
	ret %= p;
	return ret;
}
signed main()
{
   
	int x, y;
	scanf("%lld%lld%lld%lld", &n, &m, &r, &p);
	for(int i = 1; i <= n; i++)
	{
   
		scanf("%lld", &num[i]);
	}
	for(int i = 1; i < n; i++)
	{
   
		scanf("%lld%lld", &x, &y);
		add(x, y);
		add(y, x);
	}
	dep[r] = 1;
	dfs1(r);
	dfs2(r, r);
	T.build(1, 1, n);
	int opt, z;
	for(int i = 1; i <= m; i++)
	{
   
		scanf("%lld", &opt);
		if(opt == 1)
		{
   
			scanf("%lld%lld%lld", &x, &y, &z);
			addline(x, y, z);
		}
		else if(opt == 2)
		{
   
			scanf