P3384——树链剖分&&模板

题目描述

链接

如题，已知一棵包含N个结点的树（连通且无环），每个节点上包含一个数值，需要支持以下操作：

操作1： 格式： 1 x y z 表示将树从x到y结点最短路径上所有节点的值都加上z

操作2： 格式： 2 x y 表示求树从x到y结点最短路径上所有节点的值之和

操作3： 格式： 3 x z 表示将以x为根节点的子树内所有节点值都加上z

操作4： 格式： 4 x 表示求以x为根节点的子树内所有节点值之和

解决方法

用链式前向星的方式保存树，两次DFS将树剖分成若干重链和轻链，套用线段树进行更新和查询，对子树的操作可以转化成连续节点间的操作（因为DFS时子树节点的编号也是连续的），注意取模和开$long long$.

而且单独$add$标记时是不用下推的，只需查询时累加即可（不知道为什么那些题解都用下推的）

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
#define lc o <<1
#define rc o <<1 | 1
//const ll INF = 0x3f3f3f3f;
const int maxn = 200000 + 10;
struct Edge
{
    int to, next;
}edges[2*maxn];
int head[maxn];
int cur, f[maxn], deep[maxn], size[maxn], son[maxn], rk[maxn], id[maxn], top[maxn], cnt;
int n, q, w[maxn], root, mod;

inline void addedge(int u, int v)
{
    ++cur;
    edges[cur].next = head[u];
    head[u] = cur;
    edges[cur].to = v;
}

struct SegTree{
    ll sum[maxn << 2], addv[maxn << 2];
    void build(int o, int l, int r)
    {
        if(l == r)
        {
            sum[o] = w[rk[l]] % mod;
        }
        else
        {
            int mid = (l + r) >> 1;
            build(lc, l, mid);
            build(rc, mid+1, r);
            sum[o] = (sum[lc] + sum[rc]) % mod;
        }
    }

    void maintain(int o, int l, int r)
    {
        if(l == r)  //如果是叶子结点
            sum[o] = w[rk[l]] % mod;
        else     //如果是非叶子结点
            sum[o] = (sum[lc] + sum[rc]) % mod;

        sum[o] = (sum[o] + addv[o] * (r-l+1)) % mod;
    }
    //区间修改，[cl,cr] += v;
    void update(int o, int l, int r, int cl, int cr, int v)  //
    {
        if(cl <= l && r <= cr)  addv[o] = (addv[o] + v) % mod;
        else
        {
            int m = l + (r-l) /2;
            if(cl <= m)  update(lc, l, m, cl, cr, v);
            if(cr > m)  update(rc, m+1, r, cl, cr, v);
        }
        maintain(o, l, r);
    }

    //区间查询,sum{ql,qr}
    ll query(int o, int l,int r, ll add, int ql, int qr)
    {
        if(ql <= l && r <= qr)
        {
            //prllf("sum[o]:%d  %d*(%d-%d+1)
", sum[o], add, r, l);
            return (sum[o] + add * (r-l+1)) % mod;  //tx  l-r+1
        }
        else
        {
            int  m = l + (r - l) / 2;
            ll ans = 0;
            add = (add + addv[o]) % mod;
            if(ql <= m)  ans = (ans + query(lc, l, m, add, ql, qr)) % mod;
            if(qr > m)  ans = (ans + query(rc, m+1, r, add, ql, qr)) % mod;
            return ans;
        }
    }
}st;

void dfs1(int u, int fa, int depth)  //当前节点、父节点、层次深度
{
    //prllf("u:%d fa:%d depth:%d
", u, fa, depth);
    f[u] = fa;
    deep[u] = depth;
    size[u] = 1;   //这个点本身的size
    for(int i = head[u];i;i = edges[i].next)
    {
        int v = edges[i].to;
        if(v == fa)  continue;
        dfs1(v, u, depth+1);
        size[u] += size[v];   //子节点的size已被处理，用它来更新父节点的size
        if(size[v] > size[son[u]])  son[u] = v;    //选取size最大的作为重儿子
    }
}

void dfs2(int u, int t)  //当前节点、重链顶端
{
    //prllf("u:%d t:%d
", u, t);
    top[u] = t;
    id[u] = ++cnt;   //标记dfs序
    rk[cnt] = u;     //序号cnt对应节点u
    if(!son[u])  return;   //没有儿子？
    dfs2(son[u], t);  //我们选择优先进入重儿子来保证一条重链上各个节点dfs序连续

    for(int i = head[u];i;i = edges[i].next)
    {
        int v = edges[i].to;
        if(v != son[u] && v != f[u])  dfs2(v, v);  //这个点位于轻链顶端，那么它的top必然为它本身
    }
}



/*修改和查询的原理是一致的，以查询操作为例，其实就是个LCA，不过这里要使用top数组加速，因为top可以直接跳到该重链的起始顶点*/
/*注意，每次循环只能跳一次，并且让结点深的那个跳到top的位置，避免两者一起跳而插肩而过*/
ll querysum(int x, int y)
{
    int fx = top[x], fy = top[y];
    ll ans = 0;
    while(fx != fy)   //当两者不在同一条重链上
    {
        if(deep[fx] >= deep[fy])
        {
            //prllf("%d %d
", id[fx], id[x]);
            ans = (ans + st.query(1, 1, n, 0, id[fx], id[x])) % mod;   //线段树区间求和，计算这条重链的贡献
            x = f[fx]; fx = top[x];
        }
        else
        {
            //prllf("%d %d
", id[fy], id[y]);
            ans = (ans + st.query(1, 1, n, 0, id[fy], id[y])) % mod;
            y = f[fy]; fy = top[y];
        }
    }

    //循环结束，两点位于同一重链上，但两者不一定为同一点，所以还要加上这两点之间的贡献
    if(id[x] <= id[y])
    {
        //prllf("%d %d
", id[x], id[y]);
        ans = (ans + st.query(1, 1, n, 0, id[x], id[y])) % mod;
    }
    else
    {
        //prllf("%d %d
", id[y], id[x]);
        ans = (ans + st.query(1, 1, n, 0, id[y], id[x])) % mod;
    }
    return ans;
}

void update_add(int x, int y, int add)
{
    int fx = top[x], fy = top[y];
    while(fx != fy)   //当两者不在同一条重链上
    {
        if(deep[fx] >= deep[fy])
        {
            st.update(1, 1, n, id[fx], id[x], add);
            x = f[fx]; fx = top[x];
        }
        else
        {
            st.update(1, 1, n, id[fy], id[y], add);
            y = f[fy]; fy = top[y];
        }
    }
    //循环结束，两点位于同一重链上，但两者不一定为同一点，所以还要加上这两点之间的贡献
    if(id[x] <= id[y])  st.update(1, 1, n, id[x], id[y], add);
    else  st.update(1, 1, n, id[y], id[x], add);
}


int main()
{
    scanf("%d%d%d%d", &n, &q, &root, &mod);
    for(int i = 1;i <= n;i++)
    {
        scanf("%d", &w[i]);
        w[i] %= mod;
    }
    for(int i = 1;i < n;i++)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        addedge(u, v);
        addedge(v, u);
    }
    dfs1(root, -1, 1);
    dfs2(root, root);

//    for(ll i = 1;i <= n;i++)  prllf("%d  ", id[i]);
//    prllf("
");
//    for(ll i = 1;i <= n;i++)  prllf("%d  ", rk[i]);
//    prllf("
");

    st.build(1, 1, n);
    //scanf("%d", &q);
    while(q--)
    {
        int op;
        scanf("%d", &op);
        if(op == 1)
        {
            int u, v, add;
            scanf("%d%d%d", &u, &v, &add);
            update_add(u, v,  add);
        }
        else if(op == 2)
        {
            int u, v;
            scanf("%d%d", &u, &v);
            printf("%lld
", querysum(u, v));
        }
        else if(op == 3)
        {
            int u, add;
            scanf("%d%d", &u, &add);
            st.update(1, 1, n, id[u], id[u]+size[u]-1, add);
        }
        else
        {
            int u;
            scanf("%d", &u);
            printf("%lld
",st.query(1, 1, n, 0, id[u], id[u]+size[u]-1));
        }
        //st.prll_debug(1, 1, n);
    }
}