zoukankan      html  css  js  c++  java
  • luogu 3384 【模板】树链剖分

    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(重要的事情说三遍:记得取模)

    树链剖分模板题。

    说说我敲这个模板题时的感受吧。

    代码量是真的大!在线段树的基础上进行四种操作外加两个dfs,要有点心理准备。

    主要的思想就是把一棵树按重儿子优先的dfs序在叶子结点后分开,从而分成很多条链。这样就可以在线段树上进行维护了。

    有很多数组,不过都有很明确的应用,也不可取代。

    qrange,updrange的思想就是在链头较深的链上跳来跳去,还是很有意思的。

    #include <cstdio>
    #include <iostream>
    #include <algorithm>
    #include <cstring>
    #include <string>
    #include <cmath>
    #include <queue>
    #include <deque>
    #include <stack>
    #include <map>
    #include <set>
    typedef long long ll;
    const int mod=1000000007;
    const int inf=1000000000;
    const int maxn=100000;
    const int maxm=1000000;
    
    int n,m,r,p;
    int val[maxn+10];
    int to[maxn*2+10];
    int next[maxn*2+10];
    int head[maxn+10],cnt;
    
    int depth[maxn+10];//节点深度
    int siz[maxn+10];//节点子树大小
    int son[maxn+10];//有子节点的节点重儿子编号,没有为0
    int fa[maxn+10];//父亲节点编号
    
    void dfs1(int x,int f,int d)
    {
        fa[x]=f;
        depth[x]=d;
        for(int i=head[x];i!=-1;i=next[i])
        {
            int l=to[i];
            if(l!=f)
            {
                dfs1(l,x,d+1);
                siz[x]+=siz[l];
                if(son[x]==0||siz[l]>siz[son[x]])
                    son[x]=l;
            }
        }
        siz[x]++;
    }
    
    int id[maxn+10],num;//原编号到dfs序的映射
    int wt[maxn+10];//由dfs序得到节点权重
    int top[maxn+10];//链顶端的编号
    //dfs序只和id、wt数组有关,其余数组涉及的都是原编号,线段树部分完全用的是dfs序
    
    void dfs2(int x,int topf)
    {
        id[x]=num++;
        wt[id[x]]=val[x];
        top[x]=topf;
        if(son[x]==0)
            return;
        dfs2(son[x],topf);
        for(int i=head[x];i!=-1;i=next[i])
        {
            int l=to[i];
            if(l!=fa[x]&&son[x]!=l)
                dfs2(l,l);
        }
    }
    
    void init()
    {
        cnt=0;
        num=1;
        memset(head,-1,sizeof(head));
        memset(siz,0,sizeof(siz));
        memset(son,0,sizeof(son));
    }
    
    /*****以下是线段树部分(注意Tag的写法哦)*****/
    
    struct ttree
    {
        int l,r;
        int tag;
        int sum;
        inline int len()
        {
            return r-l+1;
        }
    };
    ttree tree[maxn*4+10];
    
    void pushup(int x)
    {
        if(tree[x].l==tree[x].r)
            return;
        tree[x].sum=(tree[x*2].sum+tree[x*2+1].sum)%p;
    }
    
    void pushdown(int x)
    {
        if(tree[x].l==tree[x].r)
            return;
        int tag=tree[x].tag;
        tree[x].tag=0;
        tree[x*2].tag+=tag;
        tree[x*2+1].tag+=tag;
        tree[x*2].sum=(tree[x*2].sum+tag*tree[x*2].len())%p;
        tree[x*2+1].sum=(tree[x*2+1].sum+tag*tree[x*2+1].len())%p;
    }
    
    void build(int x,int l,int r)
    {
        tree[x].l=l;
        tree[x].r=r;
        tree[x].tag=0;
        if(tree[x].l==tree[x].r)
            tree[x].sum=wt[tree[x].l];//wt数组的
        else
        {
            int mid=(l+r)/2;
            build(x*2,l,mid);
            build(x*2+1,mid+1,r);
            pushup(x);
        }
    }
    
    void modify(int x,int l,int r,int op)
    {
        if(l<=tree[x].l&&r>=tree[x].r)
        {
            tree[x].tag+=op;
            tree[x].sum=(tree[x].sum+op*tree[x].len())%p;
        }
        else
        {
            pushdown(x);
            int mid=(tree[x].l+tree[x].r)/2;
            if(l<=mid)
                modify(x*2,l,r,op);
            if(r>=mid+1)
                modify(x*2+1,l,r,op);
            pushup(x);
        }
    }
    
    int query(int x,int l,int r)
    {
        if(l<=tree[x].l&&r>=tree[x].r)
            return tree[x].sum;
        else
        {
            pushdown(x);
            int res=0;
            int mid=(tree[x].l+tree[x].r)/2;
            if(l<=mid)
                res=(res+query(x*2,l,r))%p;
            if(r>=mid+1)
                res=(res+query(x*2+1,l,r))%p;
            return res;
        }
    }
    
    /*****以上是线段树部分*****/
    
    int qrange(int x,int y)
    {
        int ans=0;
        while(top[x]!=top[y])
        {
            if(depth[top[x]]<depth[top[y]])
                std::swap(x,y);
            int res=query(1,id[top[x]],id[x]);
            ans=(ans+res)%p;
            x=fa[top[x]];
        }
        if(depth[x]<depth[y])
            std::swap(x,y);
        int res=query(1,id[y],id[x]);
        ans=(ans+res)%p;
        return ans;
    }
    
    void updrange(int x,int y,int z)
    {
        z%=p;
        while(top[x]!=top[y])
        {
            if(depth[top[x]]<depth[top[y]])
                std::swap(x,y);
            modify(1,id[top[x]],id[x],z);
            x=fa[top[x]];
        }
        if(depth[x]<depth[y])
            std::swap(x,y);
        modify(1,id[y],id[x],z);
    }
    
    int qson(int x)
    {
        return query(1,id[x],id[x]+siz[x]-1);
    }
    
    void updson(int x,int z)
    {
        modify(1,id[x],id[x]+siz[x]-1,z);
    }
    
    int main()
    {
        init();
        scanf("%d%d%d%d",&n,&m,&r,&p);
        for(int i=1;i<=n;i++)
            scanf("%d",val+i);
        for(int i=1,a,b;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            to[cnt]=b;next[cnt]=head[a];head[a]=cnt++;
            to[cnt]=a;next[cnt]=head[b];head[b]=cnt++;
        }
        dfs1(r,-1,1);
        dfs2(r,r);
        build(1,1,n);
        while(m--)
        {
            int op,x,y,z;
            scanf("%d",&op);
            if(op==1)
            {
                scanf("%d%d%d",&x,&y,&z);
                updrange(x,y,z);
            }
            if(op==2)
            {
                scanf("%d%d",&x,&y);
                printf("%d
    ",qrange(x,y));
            }
            if(op==3)
            {
                scanf("%d%d",&x,&z);
                updson(x,z);
            }
            if(op==4)
            {
                scanf("%d",&x);
                printf("%d
    ",qson(x));
            }
        }
    
        return 0;
    }
    View Code
  • 相关阅读:
    [模板]大数加法
    HDU 1848 Fibonacci again and again
    同时安装了Python2和Python3时的pip使用
    UPC-2785 One-Way Roads(最大流建图)
    UPC-2784 Model Railroad(最小生成树)
    【ICPC 2017 Daejeon】UPC-9312 Game Map(dfs)
    【ICPC 2015 Shenyang】UVALive
    【ICPC 2015 Shenyang 】UPC-9254 MEETING(最短路&虚点建图)
    UPC-9264 Chip Factory(01字典树)
    【ICPC 2018 Malaysia】UPC-9302 ELI'S CURIOUS MIND(递推)
  • 原文地址:https://www.cnblogs.com/acboyty/p/10125681.html
Copyright © 2011-2022 走看看