树链剖分——树链剖分模板

原题
给定一棵树，树中包含 n 个节点（编号 1∼n），其中第 i 个节点的权值为 ai。

初始时，1 号节点为树的根节点。

现在要对该树进行 m 次操作，操作分为以下 4 种类型：

1 u v k，修改路径上节点权值，将节点 u 和节点 v 之间路径上的所有节点（包括这两个节点）的权值增加 k。
2 u k，修改子树上节点权值，将以节点 u 为根的子树上的所有节点的权值增加 k。
3 u v，询问路径，询问节点 u 和节点 v 之间路径上的所有节点（包括这两个节点）的权值和。
4 u，询问子树，询问以节点 u 为根的子树上的所有节点的权值和。
输入格式
第一行包含一个整数 n，表示节点个数。

第二行包含 n 个整数，其中第 i 个整数表示 ai。

接下来 n−1 行，每行包含两个整数 x,y，表示节点 x 和节点 y 之间存在一条边。

再一行包含一个整数 m，表示操作次数。

接下来 m 行，每行包含一个操作，格式如题目所述。

输出格式
对于每个操作 3 和操作 4，输出一行一个整数表示答案。

数据范围
1≤n,m≤105,
0≤ai,k≤105,
1≤u,v,x,y≤n
输入样例：
5
1 3 7 4 5
1 3
1 4
1 5
2 3
5
1 3 4 3
3 5 4
1 3 5 10
2 3 5
4 1
输出样例：
16
69

树链剖分原理：通过特殊变换，将树转换成一个序列。树上任何一个路径都能通过序列中一个或者多个小区间组成表示
概念：
对于一个节点，分别求所有子树的节点总数。节点个数最多的是重儿子，如果有多个节点最多且相同的子树，则任选一个作重儿子，则其余的就都是轻儿子
重边：重儿子与父节点连接的边
其余的称为轻边
重链：极大的，由重边构成的路径，一个树可以有多个
使用dfs序将树变成序列，用dfs时要优先遍历重儿子，这样遍历可以让重链是连续的。
转换成序列之后可以用线段树+懒标记进行维护数据
当我们想要询问以u点为树根的树时，由于在dfs序是以树根开始遍历，所以在线段树中询问的左区间就是u点dfs编号，而问询右区间就是u点dfs编号+以u为根的树中点的数量-1
当问询从u点到v点的值时，如果u点和v点在同一个重链中，直接在线段树中问询两者dfs序的区间
如果不在同一个重链，先问询距离源点远的那个点到它所属的重链头的区间，再把该点移动到重链头的父节点。这个过程
更新操作同理

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;
const int N = 100010, M = N * 2;

int n, m;
int w[N], h[N], e[M], ne[M], idx;
int id[N];//dfs序的编号
int nw[N];//dfs序中第i个点的编号
int cnt;
int dep[N];//点在树的深度
int sz[N]; //该点为根的子树的大小
int top[N];//某点所属重链的顶点
int fa[N];//某点的父节点
int son[N];//某点的重儿子节点
struct Tree
{
    int l, r;
    LL add, sum;//懒标记 该子树数之和
}tr[N * 4];

void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

void dfs1(int u, int father, int depth)//当前点 父节点 深度
{
    dep[u] = depth, fa[u] = father, sz[u] = 1;
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j == father) continue;
        dfs1(j, u, depth + 1);
        sz[u] += sz[j];//加上子节点树的大小
        if (sz[son[u]] < sz[j]) son[u] = j;
        //如果当前节点的储存的重儿子的体积小于j，就要改变重儿子
    }
}

//       当前点   当前点所属重链的顶点
void dfs2(int u, int t)//建立dfs序,保证重儿子编号连续
{
    id[u] = ++ cnt;//编号
	nw[cnt] = w[u];//dfs序编号对应w中的值
	top[u] = t;
    if (!son[u]) return;//如果u点没有重儿子(或儿子)就返回
    dfs2(son[u], t);//递归重儿子
    for (int i = h[u]; ~i; i = ne[i])//遍历轻儿子
    {
        int j = e[i];
        if (j == fa[u] || j == son[u]) continue;
        dfs2(j, j);
    }
}

void pushup(int u)
{
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}

void pushdown(int u)
{
    auto &root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
    if (root.add)
    {
        left.add += root.add, left.sum += root.add * (left.r - left.l + 1);
        right.add += root.add, right.sum += root.add * (right.r - right.l + 1);
        root.add = 0;
    }
}

void build(int u, int l, int r)
{
    tr[u] = {l, r, 0, nw[r]};//这里构建的是dfs序的线段树
    if (l == r) return;
    int mid = l + r >> 1;
    build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
    pushup(u);
}

void update(int u, int l, int r, int k)//给l到r上所有点
{
    if (l <= tr[u].l && r >= tr[u].r)
    {
        tr[u].add += k;
        tr[u].sum += k * (tr[u].r - tr[u].l + 1);
        return;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid) update(u << 1, l, r, k);
    if (r > mid) update(u << 1 | 1, l, r, k);
    pushup(u);
}

LL query(int u, int l, int r)
{
    if (l <= tr[u].l && r >= tr[u].r) return tr[u].sum;
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    LL res = 0;
    if (l <= mid) res += query(u << 1, l, r);
    if (r > mid) res += query(u << 1 | 1, l, r);
    return res;
}

void update_path(int u, int v, int k)
{
	//优先走更低的那个点(离源更远)
    while (top[u] != top[v])//如果两点不在同一重链
    {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);//优先走链头离源远的那个点
        update(1, id[top[u]], id[u], k);//在dfs先遍历到的是u点的链头
        u = fa[top[u]];//将u跳到链头的父系节点
    }
    if (dep[u] < dep[v]) swap(u, v);
    update(1, id[v], id[u], k);//最后再更新一次
}

LL query_path(int u, int v)//问询同理
{
    LL res = 0;
    while (top[u] != top[v])
    {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        res += query(1, id[top[u]], id[u]);
        u = fa[top[u]];
    }
    if (dep[u] < dep[v]) swap(u, v);
    res += query(1, id[v], id[u]);
    return res;
}

void update_tree(int u, int k)//更新一个树
{
    update(1, id[u], id[u] + sz[u] - 1, k);
    //每个子树的根节点是第一个被搜到的
    //所以在线段树中是以该点开始，以该点加上体积-1结束
}

LL query_tree(int u)
{
    return query(1, id[u], id[u] + sz[u] - 1);//与update同理
}

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i ++ )
    {
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a);
    }
    dfs1(1, -1, 1);//计算每个点的重儿子
    dfs2(1, 1);//求dfs序
    build(1, 1, n);//建立线段树维护数据

    scanf("%d", &m);
    while (m -- )
    {
        int t, u, v, k;
        scanf("%d%d", &t, &u);
        if (t == 1)//给u到v上的点加k
        {
            scanf("%d%d", &v, &k);
            update_path(u, v, k);
        }
        else if (t == 2)//将u为根的子树上所有节点加K
        {
            scanf("%d", &k);
            update_tree(u, k);
        }
        else if (t == 3)//询问路径上的权值和
        {
            scanf("%d", &v);
            printf("%lld\n", query_path(u, v));
        }
        else printf("%lld\n", query_tree(u));//询问u为根的子树上节点权值和
    }

    return 0;
}