• 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
    5 5 2 24
    7 3 7 8 0 
    1 2
    1 5
    3 1
    4 1
    3 4 2
    3 2 2
    4 5
    1 5 1 3
    2 1 3
    输出 #1
    2
    21

    说明/提示

    时空限制:1s,128M

    数据规模:

    对于30%的数据: N≤10,M≤10 N leq 10, M leq 10 N10,M10

    对于70%的数据: N≤103,M≤103 N leq {10}^3, M leq {10}^3 N103,M103

    对于100%的数据: N≤105,M≤105 N leq {10}^5, M leq {10}^5 N105,M105

    #include<iostream>
    #include<stdio.h>
    #include<string.h>
    #include<algorithm>
    using namespace std;
    const int N=2e5+10;
    int sum[N*2],lazy[N*2];//线段树 
    int n,m,r,mod;//节点数,操作数,根节点,模数 
    int first[N],tot; //邻接表 
    
    int son[N],id[N],fa[N],cnt,deep[N],size[N],top[N];
    int w[N],wt[N];// 初始点权,新编号点权
    int res=0;//查询答案
    
    struct edge{
        int v,next;
    }e[N]; 
    
    void add_edge(int u,int v){
        e[tot].v=v;
        e[tot].next=first[u];
        first[u]=tot++;
    }
    
    void init(){
        memset(first,-1,sizeof(first));
        tot=0;
        cnt=0;
    }
    
    int pushup(int rt){
        sum[rt]=(sum[rt*2]+sum[rt*2+1])%mod;
    }
    
    void pushdown(int rt,int m){
        if(lazy[rt]){
            lazy[rt*2]+=lazy[rt];
            lazy[rt*2+1]+=lazy[rt];
            sum[rt*2]+=lazy[rt]*(m-(m/2));
            sum[rt*2]%=mod;
            sum[rt*2+1]+=lazy[rt]*(m/2);
            sum[rt*2+1]%=mod;
            lazy[rt]=0;
        }
    }
    
    void build(int l,int r,int v){
        lazy[v]=0;
        if(l==r){
            sum[v]=wt[l];
            sum[v]%=mod;
            return ;
        }
        int mid=(l+r)/2;
        build(l,mid,v*2);
        build(mid+1,r,v*2+1);    
        pushup(v);
    }
    
    void update(int L,int R,int c,int l,int r,int rt){
        if(L<=l&&r<=R){
            lazy[rt]+=c;
            sum[rt]+=c*(r-l+1);
            sum[rt]%=mod;
            return;
        }
        pushdown(rt,r-l+1);
        int m=(l+r)/2;
        if(L<=m) update(L,R,c,l,m,rt*2);
        if(R>m) update(L,R,c,m+1,r,rt*2+1);
        pushup(rt);
    }
    
    void query(int L,int R,int l,int r,int rt){
        if(L<=l&&r<=R){
            res+=sum[rt];
            res%=mod;
            return;
        }
        pushdown(rt,r-l+1);
        int m=(l+r)/2;
        if(L<=m) query(L,R,l,m,rt*2);
        if(R>m) query(L,R,m+1,r,rt*2+1);
    }
    
    void dfs1(int u,int f,int d){
        deep[u]=d;
        fa[u]=f;
        size[u]=1;
        int maxson=-1;
        for(int i=first[u];~i;i=e[i].next){
            int v=e[i].v;
            if(v==f) continue;
            dfs1(v,u,d+1);
            size[u]+=size[v];
            if(size[v]>maxson){
                son[u]=v;
                maxson=size[v];
            }
        }
    }
    
    void dfs2(int u,int topf){
        id[u]=++cnt;
        wt[cnt]=w[u];
        top[u]=topf;
        if(!son[u]) return ;
        dfs2(son[u],topf);
        for(int i=first[u];~i;i=e[i].next){
            int v=e[i].v;
            if(v==fa[u]||v==son[u]) continue;
            dfs2(v,v);
        }
    }
    
    
    void updrange(int x,int y,int k){
        k%=mod;
        while(top[x]!=top[y]){
            if(deep[top[x]]<deep[top[y]]) swap(x,y);
            update(id[top[x]],id[x],k,1,n,1);
            x=fa[top[x]];
        }
        if(deep[x]>deep[y]) swap(x,y);
        update(id[x],id[y],k,1,n,1);
    }
    
    int qrange(int x,int y){
        int ans=0;
        while(top[x]!=top[y]){
            if(deep[top[x]]<deep[top[y]]) swap(x,y);
            res=0;
            query(id[top[x]],id[x],1,n,1);
            ans+=res;
            ans%=mod;
            x=fa[top[x]];
        }
        if(deep[x]>deep[y]) swap(x,y);
        res=0;
        query(id[x],id[y],1,n,1);
        ans+=res;
        return ans%mod;
    }
    
    void upson(int x,int k){
        update(id[x],id[x]+size[x]-1,k,1,n,1);
    }
    
    int qson(int x){
        res=0;
        query(id[x],id[x]+size[x]-1,1,n,1);
        return res;
    }
    
    
    int main(){
        int u,v;
        scanf("%d%d%d%d",&n,&m,&r,&mod);
        init();
        for(int i=1;i<=n;i++){
            scanf("%d",&w[i]);
        }
        for(int i=1;i<=n-1;i++){
            scanf("%d%d",&u,&v);
            add_edge(u,v);
            add_edge(v,u);
        }
        dfs1(r,0,1);
        dfs2(r,r);
        build(1,n,1);
        while(m--){
            int op,x,y,z;
            scanf("%d",&op);
            if(op==1){
                scanf("%d%d%d",&x,&y,&z);
                updrange(x,y,z);
            }
            else if(op==2){
                scanf("%d%d",&x,&y);
                printf("%d
    ",qrange(x,y)); 
            }
            else if(op==3){
                scanf("%d%d",&x,&z);
                upson(x,z);
            }
            else if(op==4){
                scanf("%d",&x);
                printf("%d
    ",qson(x));
            }
        }
    } 
     
  • 相关阅读:
    代码review之 isInfoEnable()
    sdk、jdk、jre、jvm、jdt、cdt分别都是什么东西
    思考总结: 决胜21点 开篇 概率问题
    Java多线程开发系列之四:玩转多线程(线程的控制2)
    Java多线程开发系列之四:玩转多线程(线程的控制1)
    Java多线程开发系列之三:线程这一辈子(线程的生命周期)
    Java多线程开发系列之二:如何创建多线程
    [系列] Gin框架
    [系列] Gin框架
    [系列] Gin 框架
  • 原文地址:https://www.cnblogs.com/ellery/p/11588199.html
Copyright © 2020-2023  润新知