• BZOJ 4196: [Noi2015]软件包管理器


    Time Limit: 10 Sec Memory Limit: 512 MB
    Submit: 2440 Solved: 1415
    [Submit][Status][Discuss]
    Description

    Linux用户和OSX用户一定对软件包管理器不会陌生。通过软件包管理器,你可以通过一行命令安装某一个软件包,然后软件包管理器会帮助你从软件源下载软件包,同时自动解决所有的依赖(即下载安装这个软件包的安装所依赖的其它软件包),完成所有的配置。Debian/Ubuntu使用的apt-get,Fedora/CentOS使用的yum,以及OSX下可用的homebrew都是优秀的软件包管理器。

    你决定设计你自己的软件包管理器。不可避免地,你要解决软件包之间的依赖问题。如果软件包A依赖软件包B,那么安装软件包A以前,必须先安装软件包B。同时,如果想要卸载软件包B,则必须卸载软件包A。现在你已经获得了所有的软件包之间的依赖关系。而且,由于你之前的工作,除0号软件包以外,在你的管理器当中的软件包都会依赖一个且仅一个软件包,而0号软件包不依赖任何一个软件包。依赖关系不存在环(若有m(m≥2)个软件包A1,A2,A3,…,Am,其中A1依赖A2,A2依赖A3,A3依赖A4,……,Am−1依赖Am,而Am依赖A1,则称这m个软件包的依赖关系构成环),当然也不会有一个软件包依赖自己。
    现在你要为你的软件包管理器写一个依赖解决程序。根据反馈,用户希望在安装和卸载某个软件包时,快速地知道这个操作实际上会改变多少个软件包的安装状态(即安装操作会安装多少个未安装的软件包,或卸载操作会卸载多少个已安装的软件包),你的任务就是实现这个部分。注意,安装一个已安装的软件包,或卸载一个未安装的软件包,都不会改变任何软件包的安装状态,即在此情况下,改变安装状态的软件包数为0。
    Input

    输入文件的第1行包含1个正整数n,表示软件包的总数。软件包从0开始编号。

    随后一行包含n−1个整数,相邻整数之间用单个空格隔开,分别表示1,2,3,…,n−2,n−1号软件包依赖的软件包的编号。
    接下来一行包含1个正整数q,表示询问的总数。
    之后q行,每行1个询问。询问分为两种:
    installx:表示安装软件包x
    uninstallx:表示卸载软件包x
    你需要维护每个软件包的安装状态,一开始所有的软件包都处于未安装状态。对于每个操作,你需要输出这步操作会改变多少个软件包的安装状态,随后应用这个操作(即改变你维护的安装状态)。
    Output

    输出文件包括q行。

    输出文件的第i行输出1个整数,为第i步操作中改变安装状态的软件包数。
    Sample Input

    7

    0 0 0 1 1 5

    5

    install 5

    install 6

    uninstall 1

    install 4

    uninstall 0
    Sample Output

    3

    1

    3

    2

    3
    HINT

    一开始所有的软件包都处于未安装状态。

    安装 5 号软件包,需要安装 0,1,5 三个软件包。

    之后安装 6 号软件包,只需要安装 6 号软件包。此时安装了 0,1,5,6 四个软件包。

    卸载 1 号软件包需要卸载 1,5,6 三个软件包。此时只有 0 号软件包还处于安装状态。

    之后安装 4 号软件包,需要安装 1,4 两个软件包。此时 0,1,4 处在安装状态。

    最后,卸载 0 号软件包会卸载所有的软件包。

    n=100000

    q=100000

    题解

    因为题目中的依赖关系是一棵树,并且要求的是树上的点权和,我们就想到树链剖分,安装
    相当于让x到根的链权值变为1,卸载相当于让x的子树的权值都变为0
    有一个小技巧是只需要记录根的sum值,然后与操作后的作差即可。
    

    代码

    #include<bits/stdc++.h>
    
    using namespace std;
    const int MAXN = 200005;
    
    inline int rd(){
        int x=0,f=1;char ch=getchar();
        while(ch<'0' || ch>'9') {if(ch=='-') f=-1;ch=getchar();}
        while(ch>='0' && ch<='9') {x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
        return x*f;
    }
    
    struct Edge{
        int nxt,to;
    }edge[MAXN*2];
    
    struct Node{
        int sum,lazy;
    }node[MAXN*2];
    
    int n,q,id[MAXN],num,d[MAXN],top[MAXN]; 
    int head[MAXN],cnt,fa[MAXN],son[MAXN],siz[MAXN];
    
    inline void add(int bg,int ed){
        edge[++cnt].to=ed;
        edge[cnt].nxt=head[bg];
        head[bg]=cnt;
    }
    
    inline void dfs1(int x,int father,int dep){
        d[x]=dep;
        fa[x]=father;
        siz[x]=1;
        int maxson=-1;
        for(register int i=head[x];i;i=edge[i].nxt){
            int u=edge[i].to;
            if(u==father) continue;
            dfs1(u,x,dep+1);
            siz[x]+=siz[u];
            if(siz[u]>maxson) {son[x]=u;maxson=siz[u];}
        }
    }
    
    inline void dfs2(int x,int topf){
        id[x]=++num;
        top[x]=topf;
        if(!son[x]) return;
        dfs2(son[x],topf);
        for(register int i=head[x];i;i=edge[i].nxt){
            int u=edge[i].to;
            if(u==fa[x] || u==son[x]) continue;
            dfs2(u,u);
        }
    }
    
    inline void pushup(int x){
        node[x].sum=node[x<<1].sum+node[x<<1|1].sum;
    }
    
    inline void pushdown(int x,int ls,int rs){
        if(node[x].lazy!=-1){
            node[x<<1].lazy=node[x].lazy;
            node[x<<1].sum=ls*node[x].lazy;
            node[x<<1|1].lazy=node[x].lazy;
            node[x<<1|1].sum=rs*node[x].lazy;
            node[x].lazy=-1;
        }
    }
    
    inline void build(int x,int L,int R){
        if(L==R){
            node[x].lazy=-1;
            return;
        }
        int mid=(L+R)>>1;
        build(x<<1,L,mid);
        build(x<<1|1,mid+1,R);
    }
    
    inline void update(int x,int L,int R,int l,int r,int k){
        if(l<=L && R<=r){
            node[x].sum=(R-L+1)*k;
            node[x].lazy=k;
            return;
        }
        int mid=(L+R)>>1;
        pushdown(x,mid-L+1,R-mid);
        if(mid>=l) update(x<<1,L,mid,l,r,k);
        if(mid<r) update(x<<1|1,mid+1,R,l,r,k);
        pushup(x);
    }
    
    inline void updRange(int x,int y,int z){
        while(top[x]!=top[y]){
            update(1,1,n,id[top[x]],id[x],z);
            x=fa[top[x]];
        }   
        x^=y^=x^=y;
        update(1,1,n,id[x],id[y],z);    
    }
    
    int main(){
        n=rd();
        for(register int i=2;i<=n;i++) {   //个人记录习惯.
            int x;x=rd();
            add(x+1,i);add(i,x+1);
        }
        q=rd();
        dfs1(1,1,1);
        dfs2(1,1);
        build(1,1,n);
        while(q--){
            char c[MAXN];
            scanf("%s",c+1);
            if(c[1]=='i'){
                int x;
                x=rd();x++;
                int pre=node[1].sum;
                updRange(x,1,1);
                printf("%d
    ",node[1].sum-pre);
            }
            else{
                int x;
                x=rd();x++;
                int pre=node[1].sum;
                update(1,1,n,id[x],id[x]+siz[x]-1,0);
                printf("%d
    ",pre-node[1].sum);
            }
        }
        return 0;
    }
  • 相关阅读:
    python代码工具化
    爬虫姓名测试打分2
    windows远程桌面设置
    scorecard用法
    C#本地应用向钉钉推送信息并在钉钉上创建审批流完成审批
    ConfigurationManager.GetSection()方法的使用
    C# 接口调用并解析json字符串
    线程与进程的区别
    Qt 事件的产生与处理
    java中Random的使用
  • 原文地址:https://www.cnblogs.com/sdfzsyq/p/9677033.html
Copyright © 2020-2023  润新知