luogu3384【模板】树链剖分

本文链接：https://blog.csdn.net/LJC00118/article/details/79952486

题目链接
题目大意：
对一颗树进行四种操作

u 到 v 路径加 z
u 到 v 路径之和
u 及 u 子树加 z
u 及 u子树之和

考虑树链剖分套线段树(懒标记必须的)
每个点的重儿子是儿子当中子树大小最大的一个
进行两次dfs，分出链头及一些奇怪的东西
进行剖分时维护每个节点的size(子树大小和)值，dfs序，pre(与dfs序互为双射)
每一条链上的dfs序一定是连续的，考虑用一颗全局线段树维护
考虑3、4操作
进行剖分时，任何一个节点和它的子树的dfs序一定是连续的，用全局线段树维护
考虑1、2操作
当两个节点不在同一条链上时，将链头深的向上跳，跳到链头的父亲，并维护线段树中的和

#include<bits/stdc++.h>
#define stop system("pause")
#define N 100001
using namespace std;

struct Edge
{
    int u, v, next;
}G[N << 1];

struct tree
{
    int l, r, sum, f;
}p[N << 2];

int head[N], d[N], fa[N], wson[N], top[N], size[N], dis[N], pre[N], w[N];
// dis -> dfs顺序, pre[n] -> dfs 序为 n 的点的编号 
int tot = 0, cur = 0;
int n, m, root, mo, ans;

inline int read()
{
    char c = getchar();
    int f = 0, fu = 1;
    while(c < '0' || c > '9') 
    {
        if(c == '-') fu = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9')
    {
        f = (f << 3) + (f << 1) + c - 48;
        c = getchar();
    }
    return f * fu;
}
inline void addedge(int u, int v)
{
    G[++tot].u = u, G[tot].v = v, G[tot].next = head[u], head[u] = tot;
    G[++tot].u = v, G[tot].v = u, G[tot].next = head[v], head[v] = tot;
}
inline void dfs1(int u, int f)
{
    size[u] = 1;
    for(int i = head[u]; i; i = G[i].next)
    {
        int v = G[i].v;
        if(v == f) continue;
        fa[v] = u;
        d[v] = d[u] + 1;
        dfs1(v, u);
        size[u] += size[v];
        if(size[v] > size[wson[u]]) wson[u] = v;
    }
}
inline void dfs2(int u, int tp)
{
    dis[u] = ++cur, pre[cur] = u;
    top[u] = tp;
    if(wson[u]) dfs2(wson[u], tp);
    for(int i = head[u]; i; i = G[i].next)
    {
        int v = G[i].v;
        if(v == fa[u] || v == wson[u]) continue;
        dfs2(v, v);
    }
}
inline void lazy(int u)
{
    p[u << 1].f += p[u].f;
    p[u << 1].f %= mo;
    p[(u << 1) + 1].f += p[u].f;
    p[(u << 1) + 1].f %= mo;
    p[u << 1].sum += p[u].f * (p[u << 1].r - p[u << 1].l + 1);
    p[u << 1].sum %= mo;
    p[(u << 1) + 1].sum += p[u].f * (p[(u << 1) + 1].r - p[(u << 1) + 1].l + 1);
    p[(u << 1) + 1].sum %= mo;
    p[u].f = 0;
}
inline void create(int u, int l, int r)
{
    p[u].l = l, p[u].r = r, p[u].f = 0;
    if(l == r)
    {
        p[u].sum = w[pre[l]] % mo;
        return;
    }
    int mid = (l + r) >> 1;
    create(u << 1, l, mid);
    create((u << 1) + 1, mid + 1, r);
    p[u].sum = (p[u << 1].sum + p[(u << 1) + 1].sum) % mo;
}
inline void modify(int u, int l, int r, int x) // [l, r] + x
{
    if(p[u].l >= l && p[u].r <= r)
    {
        p[u].sum = (p[u].sum + (p[u].r - p[u].l + 1) * x) % mo;
        p[u].f += x;
        return;
    }
    if(p[u].f) lazy(u);
    int mid = (p[u].l + p[u].r) >> 1;
    if(mid >= l) modify(u << 1, l, r, x);
    if(mid + 1 <= r) modify((u << 1) + 1, l, r, x);
    p[u].sum = (p[u << 1].sum + p[(u << 1) + 1].sum) % mo;
}
inline void ask(int u, int l, int r)
{
    if(p[u].l >= l && p[u].r <= r)
    {
        ans += p[u].sum;
        ans %= mo;
        return;
    }
    if(p[u].f) lazy(u);
    int mid = (p[u].l + p[u].r) >> 1;
    if(mid >= l) ask(u << 1, l, r);
    if(mid + 1 <= r) ask((u << 1) + 1, l, r);
    p[u].sum = (p[u << 1].sum + p[(u << 1) + 1].sum) % mo;
}
inline void qsum_line(int x, int y, int z)
{
    while(top[x] != top[y])
    {
        if(d[top[x]] < d[top[y]]) swap(x, y);
        modify(1, dis[top[x]], dis[x], z);
        x = fa[top[x]];
    }
    if(dis[x] > dis[y]) swap(x, y);
    modify(1, dis[x], dis[y], z);
}
inline void query_line(int x, int y)
{
    ans = 0;
    while(top[x] != top[y])
    {
        if(d[top[x]] < d[top[y]]) swap(x, y);
        ask(1, dis[top[x]], dis[x]);
        x = fa[top[x]];
    }
    if(dis[x] > dis[y]) swap(x, y);
    ask(1, dis[x], dis[y]);
}
inline void qsum_tree(int x, int y)
{
    modify(1, dis[x], dis[x] + size[x] - 1, y);
}
inline void query_tree(int x)
{
    ans = 0;
    ask(1, dis[x], dis[x] + size[x] - 1);
}
inline void dfs3(int u)
{
    ans = 0;
    ask(1, dis[u], dis[u]);
    printf("dis[%d] = %d, pre[%d] = %d, w[%d] = %d\n", u, dis[u], u, pre[u], u, ans);
    for(int i = head[u]; i; i = G[i].next)
    {
        int v = G[i].v;
        if(v == fa[u]) continue;
        dfs3(v);
    }
}

int main()
{
    n = read(), m = read(), root = read(), mo = read();
    for(int i = 1; i <= n; i++) w[i] = read();
    for(int i = 1; i < n; i++)
    {
        int a = read(), b = read();
        addedge(a, b);
    }
    dfs1(root, 0), dfs2(root, root);
    create(1, 1, n);
    for(int i = 1; i <= m; i++)
    {
        int a = read();
        if(a == 1)
        {
            int b = read(), c = read(), d = read();
            qsum_line(b, c, d);
        }
        if(a == 2)
        {
            int b = read(), c = read();
            query_line(b, c);
            printf("%d\n", ans);
        }
        if(a == 3)
        {
            int b = read(), c = read();
            qsum_tree(b, c);
        }
        if(a == 4)
        {
            int b = read();
            query_tree(b);
            printf("%d\n", ans);
        }
    }
    return 0;
}