• 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 leq 10, M leq 10N10,M10

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

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

    ( 其实,纯随机生成的树LCA+暴力是能过的,可是,你觉得可能是纯随机的么233 )

    样例说明:

    树的结构如下:

    各个操作如下:

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

    树剖挺简单的东西

    // luogu-judger-enable-o2
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<cmath>
    #include<algorithm>
    using namespace std;
    
    const int N=1e5+5;
    
    int n,m,RT,mod;
    int w[N];
    int opt,x,y,z;
    int head[N],num_edge;
    struct Node
    {
        int fa,son;
        int size,dep,top;
        int s,t;
    }node[N];    //dfs后的树剖节点 
    int bound;    //dfs序的右端点 
    struct Edge
    {
        int v,nxt;
    }edge[N<<1];
    struct TREE
    {
        TREE *lson,*rson;
        int l,r,mid;
        int sum;
        int addval;
    }tree[N<<2];
    typedef TREE* Tree;
    Tree now_node=tree,Root;
    
    inline int read()
    {
        char c=getchar();int num=0;
        for(;!isdigit(c);c=getchar());
        for(;isdigit(c);c=getchar())
            num=num*10+c-'0';
        return num;
    }
    
    inline void add_edge(int u,int v)
    {
        edge[++num_edge].v=v;
        edge[num_edge].nxt=head[u];
        head[u]=num_edge;
    }
    
    void dfs1(int u)    //找每个点的爸爸、重儿子、深度 
    {
        node[u].size=1;
        for(int i=head[u],v;i;i=edge[i].nxt)
        {
            v=edge[i].v;
            if(v==node[u].fa)
                continue;
            node[v].fa=u;
            node[v].dep=node[u].dep+1;
            dfs1(v);
            node[u].size+=node[v].size;
            if(node[v].size>node[node[u].son].size)
                node[u].son=v;
        }
    }
    
    void dfs2(int u,int top)
    {
        node[u].top=top;
        node[u].s=++bound;
        if(node[u].son)
        {
            dfs2(node[u].son,top);
            for(int i=head[u],v;i;i=edge[i].nxt)
            {
                v=edge[i].v;
                if(v==node[u].fa||v==node[u].son)
                    continue;
                dfs2(v,v);
            }
        }
        node[u].t=bound;
    }
    
    void build(Tree &root,int l,int r)
    {
        root=++now_node;
        root->l=l,root->r=r,root->mid=l+r>>1;
        if(l==r)
            return;
        build(root->lson,l,root->mid);
        build(root->rson,root->mid+1,r);
    }
    
    inline void pushdown(Tree root)
    {
        if(root->addval)
        {
            root->lson->addval+=root->addval;
            root->rson->addval+=root->addval;
            root->lson->addval%=mod;
            root->rson->addval%=mod;
            root->lson->sum+=(root->lson->r-root->lson->l+1)*root->addval;
            root->rson->sum+=(root->rson->r-root->rson->l+1)*root->addval;
            root->lson->sum%=mod;
            root->rson->sum%=mod;
            root->addval=0;
        }
    }
    
    void update(const Tree &root,int l,int r,int k)
    {
        if(l<=root->l&&root->r<=r)
        {
            root->sum+=(root->r-root->l+1)*k;
            root->addval+=k;
            root->addval%=mod;
            return;
        }
        pushdown(root);
        if(r<=root->mid)
            update(root->lson,l,r,k);
        else if(l>root->mid)
            update(root->rson,l,r,k);
        else
        {
            update(root->lson,l,root->mid,k);
            update(root->rson,root->mid+1,r,k);
        }
        root->sum=root->lson->sum+root->rson->sum;
        root->sum%=mod;
    }
    
    int query(const Tree &root,int l,int r)
    {
        if(l<=root->l&&root->r<=r)
            return root->sum;
        pushdown(root);
        if(r<=root->mid)
            return query(root->lson,l,r);
        else if(l>root->mid)
            return query(root->rson,l,r);
        else
            return (query(root->lson,l,root->mid)+query(root->rson,root->mid+1,r))%mod;
    }
    
    inline void Modify(int x,int y,int z)
    {
        int fx=node[x].top,fy=node[y].top;
        while(fx!=fy)
        {
            if(node[fx].dep>node[fy].dep)
            {
                update(Root,node[fx].s,node[x].s,z);
                x=node[fx].fa;
                fx=node[x].top;
            }
            else
            {
                update(Root,node[fy].s,node[y].s,z);
                y=node[fy].fa;
                fy=node[y].top;
            }
        }
        if(node[x].dep>node[y].dep)
            update(Root,node[y].s,node[x].s,z);
        else
            update(Root,node[x].s,node[y].s,z);
    }
    
    inline int Query(int x,int y)
    {
        int fx=node[x].top,fy=node[y].top;
        int ans=0;
        while(fx!=fy)
        {
            if(node[fx].dep>node[fy].dep)
            {
                ans+=query(Root,node[fx].s,node[x].s);
                x=node[fx].fa;
                fx=node[x].top;
            }
            else
            {
                ans+=query(Root,node[fy].s,node[y].s);
                y=node[fy].fa;
                fy=node[y].top;
            }    
        }
        if(node[x].dep>node[y].dep)
            ans+=query(Root,node[y].s,node[x].s);
        else
            ans+=query(Root,node[x].s,node[y].s);
        return ans%mod;
    }
    
    int main()
    {
        n=read(),m=read(),RT=read(),mod=read();
        for(int i=1;i<=n;++i)
            w[i]=read();
        for(int i=1,u,v;i<n;++i)
        {
            u=read(),v=read();
            add_edge(u,v);
            add_edge(v,u);
        }
        dfs1(RT);
        dfs2(RT,RT);
        build(Root,1,n);
        for(int i=1;i<=n;++i)
            update(Root,node[i].s,node[i].s,w[i]);
        while(m--)
        {
            opt=read();
            switch(opt)
            {
                case 1:
                    x=read(),y=read(),z=read();
                    Modify(x,y,z);
                    break;
                case 2:
                    x=read(),y=read();
                    printf("%d
    ",Query(x,y));
                    break;
                case 3:
                    x=read(),z=read();
                    update(Root,node[x].s,node[x].t,z);
                    break;
                default:
                    x=read();
                    printf("%d
    ",query(Root,node[x].s,node[x].t));
            }
        }
        return 0;
    }
  • 相关阅读:
    Swift:属性观察器
    swift:谈谈swift几种常见属性的区别
    iOS:崩溃统计工具Crashlytics的使用
    【互动出版网】2013双11全场科技图书六折包邮
    【互动出版网】11.11购物狂欢节重磅大促,免费领万千优惠券
    C#编程兵书
    C++编程兵书
    HTML+CSS网站开发兵书
    Java编程兵书
    网络运维与管理2013超值精华本
  • 原文地址:https://www.cnblogs.com/lovewhy/p/8544606.html
Copyright © 2020-2023  润新知