luogu P3384 【模板】树链剖分（树链剖分+线段树区间更新，区间查询）

最新推荐文章于 2021-09-05 22:58:10 发布

YOONGI

最新推荐文章于 2021-09-05 22:58:10 发布

阅读量138

点赞数

分类专栏：树链剖分

本文链接：https://blog.csdn.net/chimchim04/article/details/96160897

版权

树链剖分专栏收录该内容

8 篇文章 0 订阅

订阅专栏

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为根节点的子树内所有节点值之和

输入输出格式

输入格式：

第一行包含4个正整数N、M、R、P，分别表示树的结点个数、操作个数、根节点序号和取模数（即所有的输出结果均对此取模）。

接下来一行包含N个非负整数，分别依次表示各个节点上初始的数值。

接下来N-1行每行包含两个整数x、y，表示点x和点y之间连有一条边（保证无环且连通）

接下来M行每行包含若干个正整数，每行表示一个操作，格式如下：

操作1： 1 x y z

操作2： 2 x y

操作3： 3 x z

操作4： 4 x

输出格式：

输出包含若干行，分别依次表示每个操作2或操作4所得的结果（对P取模）

输入输出样例

输入样例#1： 复制

输出样例#1： 复制

2
21

说明

时空限制：1s，128M

数据规模：

对于30%的数据： N \leq 10, M \leq 10N≤10,M≤10

对于70%的数据： N \leq {10}^3, M \leq {10}^3N≤103,M≤103

对于100%的数据： N \leq {10}^5, M \leq {10}^5N≤105,M≤105

（其实，纯随机生成的树LCA+暴力是能过的，可是，你觉得可能是纯随机的么233 ）

样例说明：

树的结构如下：

各个操作如下：

故输出应依次为2、21(重要的事情说三遍：记得取模)

题目链接：https://www.luogu.org/problemnew/show/P3384

如果还没有学树链剖分可以参考这篇博客：树链剖分详解

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
const int N=200005;
int n,m,root,mod,tot,cnt;
int first[N],lazy[N<<2],sum[N<<2],w[N],wt[N];
int d[N],fa[N],siz[N],son[N],top[N],id[N],rk[N];
struct node
{
    int v,nex;
}e[N<<1];
void adde(int u,int v)
{
    e[tot].v=v;
    e[tot].nex=first[u];
    first[u]=tot++;
}
void init()
{
    tot=cnt=0;
    memset(first,-1,sizeof(first));
    memset(son,0,sizeof(son));
}
void dfs1(int u,int pre,int depth) //处理 d,fa,siz,son 数组
{
    d[u]=depth;
    fa[u]=pre;
    siz[u]=1;
    for(int i=first[u];~i;i=e[i].nex)
    {
        int v=e[i].v;
        if(v==pre) continue;
        dfs1(v,u,depth+1);
        siz[u]+=siz[v];
        if(siz[v]>siz[son[u]])
            son[u]=v;
    }
}
void dfs2(int u,int t) //处理 top id rk wt 数组
{
    top[u]=t;
    id[u]=++cnt;
    rk[cnt]=u;
    wt[cnt]=w[u];
    if(!son[u]) return;
    dfs2(son[u],t);
    for(int i=first[u];~i;i=e[i].nex)
    {
        int v=e[i].v;
        if(v!=son[u]&&v!=fa[u])
            dfs2(v,v);
    }
}
void pushup(int rt)
{
    sum[rt]=(sum[rt<<1]+sum[rt<<1|1])%mod;
}
void build(int l,int r,int rt) //建线段树
{
    lazy[rt]=0;
    if(l==r)
    {
        sum[rt]=wt[l]%mod;
        return;
    }
    int mid=(l+r)>>1;
    build(lson);
    build(rson);
    pushup(rt);
}
void pushdown(int rt,int m) //向下更新lazy标记
{
    if(lazy[rt])
    {
        lazy[rt<<1]+=lazy[rt];
        lazy[rt<<1|1]+=lazy[rt];
        sum[rt<<1]+=lazy[rt]*(m-(m>>1));
        sum[rt<<1|1]+=lazy[rt]*(m>>1);
        sum[rt<<1]%=mod,sum[rt<<1|1]%=mod;
        lazy[rt]=0;
    }
}
void update(int L,int R,int c,int l,int r,int rt) //[L,R]区间加c
{
    if(L<=l&&r<=R)
    {
        lazy[rt]+=c;
        sum[rt]+=c*(r-l+1);
        sum[rt]%=mod;
        return;
    }
    pushdown(rt,r-l+1);
    int mid=(l+r)>>1;
    if(L<=mid) update(L,R,c,lson);
    if(mid<R) update(L,R,c,rson);
    pushup(rt);
}
int query(int L,int R,int l,int r,int rt) // 查询[L,R]区间的和
{
    if(L<=l&&r<=R)
        return sum[rt]%mod;
    pushdown(rt,r-l+1);
    int mid=(l+r)>>1,ans=0;
    if(L<=mid) ans+=query(L,R,lson);
    if(mid<R) ans+=query(L,R,rson);
    return ans%mod;
}

void uprange(int x,int y,int z) //x到y的最短路径加z
{
    z%=mod;
    while(top[x]!=top[y])
    {
        if(d[top[x]]<d[top[y]]) swap(x,y);
        update(id[top[x]],id[x],z,1,n,1);
        x=fa[top[x]];
    }
    if(d[x]>d[y]) swap(x,y);
    update(id[x],id[y],z,1,n,1);
}
int querange(int x,int y) //求x到y的最短路径的和
{
    int ans=0;
    while(top[x]!=top[y])
    {
        if(d[top[x]]<d[top[y]]) swap(x,y);
        ans+=query(id[top[x]],id[x],1,n,1);
        ans%=mod;
        x=fa[top[x]];
    }
    if(d[x]>d[y]) swap(x,y);
    ans+=query(id[x],id[y],1,n,1);
    return ans%mod;
}
void upson(int x,int z)//x的子树加z(包括x)
{//x子树的id编号是连续的，又知道子树节点个数
    update(id[x],id[x]+siz[x]-1,z,1,n,1);
}
int queson(int x)//求x的子树的和(包括x)
{
    int ans;
    ans=query(id[x],id[x]+siz[x]-1,1,n,1);
    return ans%mod;
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&root,&mod);
    init();
    for(int i=1;i<=n;i++)
        scanf("%d",&w[i]);
    int u,v;
    for(int i=1;i<n;i++) //存原树
    {
        scanf("%d%d",&u,&v);
        adde(u,v);
        adde(v,u);
    }
    dfs1(root,0,1);
    dfs2(root,root);
    build(1,n,1);
    int op,x,y,z;
    while(m--)
    {
        scanf("%d",&op);
        if(op==1)
        {
            scanf("%d%d%d",&x,&y,&z);
            uprange(x,y,z);
        }
        else if(op==2)
        {
            scanf("%d%d",&x,&y);
            printf("%d\n",querange(x,y));
        }
        else if(op==3)
        {
            scanf("%d%d",&x,&z);
            upson(x,z);
        }
        else if(op==4)
        {
            scanf("%d",&x);
            printf("%d\n",queson(x));
        }
    }
    return 0;
}