P3384 【模板】轻重链剖分/树链剖分

题目传送门：https://www.luogu.com.cn/problem/P3384

详解可看：https://blog.csdn.net/a_forever_dream/article/details/80651308 /or/ https://oi-wiki.org/graph/hld/#_6

 

树链剖分用于将树分割成若干条链的形式，以维护树上路径的信息。

 

具体来说，将整棵树剖分为若干条链，使它组合成线性结构，然后用其他的数据结构维护信息。

 

 

重链剖分能保证划分出的每条链上的节点 DFS 序连续，因此可以方便地用一些维护序列的数据结构（如线段树）来维护树上路径的信息。

 

如：

 

1. 修改 树上两点之间的路径上 所有点的值。
2. 查询 树上两点之间的路径上 节点权值的 和/极值/其它（在序列上可以用数据结构维护，便于合并的信息）。

 

除了配合数据结构来维护树上路径信息，树剖还可以用来 （且常数较小）地求 LCA。在某些题目中，还可以利用其性质来灵活地运用树剖。

 

代码：我根据自己的代码风格，修改了一部分。

 

#include<iostream>
#include<cstdio>
#include<vector>
#include<map>
#include<queue>
#include<set>
#include<algorithm>
#include<stack>
#include<cmath>
#include<cstring>
#include<string>
using namespace std;
#define int long long
#define gc getchar()
#define rd(x) read(x)
#define el '\n'
#define rep(i, a, n) for(int i = (a); i <= n; ++i)
#define per(i, a, n) for(int i = (a); i >= n; --i)
using ll = long long;
using db = double;
using ldb = long double;
const int N = 500000 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;

template <typename _T>
inline void read(_T & f) {
    f = 0; _T fu = 1; char c = gc;
    while (c < '0' || c > '9') { if (c == '-') { fu = -1; } c = gc; }
    while (c >= '0' && c <= '9') { f = (f << 3) + (f << 1) + (c & 15); c = gc; }
    f *= fu;
}

template <typename T>
void print(T x) {
    if (x < 0) putchar('-'), x = -x;
    if (x < 10) putchar(x + 48);
    else print(x / 10), putchar(x % 10 + 48);
}

template <typename T>
void print(T x, char t) {
    print(x); putchar(t);
}

struct node {
    int to, w, next;
}e[N << 2];
int head[N << 2], tot;

void add(int u, int v) {
    e[tot].to = v;
    //e[tot].w = w;
    e[tot].next = head[u];
    head[u] = tot++;
}

int dep[N], fa[N], siz[N], son[N];

void dfs1(int x) {
    siz[x] = 1;
    for (int i = head[x]; i + 1; i = e[i].next) {
        int to = e[i].to;
        if (to == fa[x]) continue;
        dep[to] = dep[x] + 1;
        fa[to] = x;
        dfs1(to);
        siz[x] += siz[to];
        if (siz[to] > siz[son[x]]) son[x] = to;
    }
}

int top[N], rnk[N], ctr[N], dfn[N], cnt;

void dfs2(int x, int tp) {
    top[x] = tp;
    dfn[x] = ++cnt;
    rnk[cnt] = x;
    if (son[x]) dfs2(son[x], tp);
    for (int i = head[x]; i + 1; i = e[i].next) {
        int to = e[i].to;
        if (to != son[x] && to != fa[x]) dfs2(to, to);
    }
    ctr[x] = cnt;
}

int w[N], p;
int n, m, root;

struct SegTree {
    int sum[N << 4], lazy[N << 4];
    void PushUp(int rt) {
        sum[rt] = sum[rt << 1] + sum[rt << 1 | 1];
    }
    void Build(int l, int r, int rt) {
        if (l == r) {
            sum[rt] = w[rnk[l]];
            return;
        }
        int m = (l + r) >> 1;
        Build(l, m, rt << 1);
        Build(m + 1, r, rt << 1 | 1);
        PushUp(rt);
    }
    void PushDown(int rt, int ln, int rn) {
        if (lazy[rt]) {
            lazy[rt << 1] += lazy[rt];
            lazy[rt << 1 | 1] += lazy[rt];
            sum[rt << 1] += lazy[rt] * ln;
            sum[rt << 1 | 1] += lazy[rt] * rn;
            lazy[rt] = 0;
        }
    }
    void Update(int L, int R, int C, int l, int r, int rt) {
        if (l >= L && r <= R) {
            sum[rt] += C * (r - l + 1);
            lazy[rt] += C;
            return;
        }
        int m = (l + r) >> 1;
        PushDown(rt, m - l + 1, r - m);
        if (m >= L) Update(L, R, C, l, m, rt << 1);
        if (m < R) Update(L, R, C, m + 1, r, rt << 1 | 1);
        PushUp(rt);
    }
    int Query(int L, int R, int l, int r, int rt) {
        if (l >= L && r <= R) {
            return sum[rt];
        }
        int m = (l + r) >> 1;
        PushDown(rt, m - l + 1, r - m);
        int ans = 0;
        if(m >= L) ans = (ans + Query(L, R, l, m, rt << 1)) % p;
        if(m < R) ans = (ans + Query(L, R, m + 1, r, rt << 1 | 1)) % p;
        return ans % p;
    }
}st;

void change_xtoy() {
    int x, y, z;
    cin >> x >> y >> z;
    while (top[x] != top[y]) {
        if (dep[top[x]] > dep[top[y]]) swap(x, y);
        st.Update(dfn[top[y]], dfn[y], z, 1, cnt, 1);
        y = fa[top[y]];
    }
    if (dep[x] > dep[y]) swap(x, y);
    st.Update(dfn[x], dfn[y], z, 1, cnt, 1);
}

void getsum_xtoy() {
    int x, y;
    cin >> x >> y;
    ll ans = 0;
    while (top[x] != top[y]) {
        if (dep[top[x]] > dep[top[y]]) swap(x, y);
        ans = (ans + st.Query(dfn[top[y]], dfn[y], 1, cnt, 1)) % p;
        y = fa[top[y]];
    }
    if (dep[x] > dep[y]) swap(x, y);
    ans = (ans + st.Query(dfn[x], dfn[y], 1, cnt, 1)) % p;
    cout << ans << "\n";
}

void change_sontree() {
    int x, z;
    cin >> x >> z;
    st.Update(dfn[x], ctr[x], z, 1, cnt, 1);
}

void getsum_sontree() {
    int x;
    cin >> x;
    cout << st.Query(dfn[x], ctr[x], 1, cnt, 1) << "\n";
}

signed main() {

    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cin >> n >> m >> root >> p;
    memset(head, -1, sizeof(head));
    tot = 0;
    for (int i = 1; i <= n; i++) {
        cin >> w[i];
    }
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        add(u, v);
        add(v, u);
    }
    dfs1(root);
    dfs2(root, root);
    st.Build(1, cnt, 1);
    for (; m; --m) {
        int op;
        cin >> op;
        if (op == 1) change_xtoy();
        if (op == 2) getsum_xtoy();
        if (op == 3) change_sontree();
        if (op == 4) getsum_sontree();
    }

    return 0;
}

//8 10 2 448348
//458 718 447 857 633 264 238 944
//1 2
//2 3
//3 4
//6 2
//1 5
//5 7
//8 6
//3 7 611
//4 6
//3 1 267
//3 2 111
//1 6 3 153
//3 7 673
//4 8
//2 6 1
//4 7
//3 4 228