软件包管理器(树链剖分)

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。

输入格式

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

随后一行包含 n−1 个整数，相邻整数之间用单个空格隔开，分别表示 1,2,3,…,n−2,n−1 号软件包依赖的软件包的编号。

接下来一行包含 1 个正整数 q，表示询问的总数。

之后 q 行，每行 1 个询问。询问分为两种：

• install x：表示安装软件包 x
• uninstall x：表示卸载软件包 x

你需要维护每个软件包的安装状态，一开始所有的软件包都处于未安装状态。

对于每个操作，你需要输出这步操作会改变多少个软件包的安装状态，随后应用这个操作（即改变你维护的安装状态）。

输出格式

输出文件包括 q 行。

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

数据范围

输入样例1：

7
0 0 0 1 1 5
5
install 5
install 6
uninstall 1
install 4
uninstall 0

输出样例1：

3
1
3
2
3

输入样例2：

10
0 1 2 1 3 0 0 3 2
10
install 0
install 3
uninstall 2
install 7
install 5
install 9
uninstall 9
install 4
install 1
install 9

输出样例2

1
3
2
1
3
1
1
1
0
1

难度：困难

时/空限制：1s / 64MB

总通过数：878

总尝试数：1427

来源：NOI2015

算法标签

---

挑战模式

 

#include <iostream>
#include <cstring>
using namespace std;
constexpr int N=1e5+7;
int h[N],e[N],ne[N],idx;
int dep[N],sz[N],top[N],fa[N],son[N];
int id[N],cnt;
struct node{
    int l,r;
    int  add,sum;
}tr[N*4];

void add(int a,int b){
    e[idx]=b;
    ne[idx]=h[a];
    h[a]=idx++;

}
void dfs1(int u,int depth){
    dep[u]=depth,sz[u]=1;
    for(int i=h[u];i!=-1;i=ne[i]){
        int j=e[i];
            dfs1(j,depth+1);
            sz[u]+=sz[j];
            if(sz[son[u]]<sz[j]) son[u]=j;
    }
}
void dfs(int u,int t){
    id[u]=++cnt,top[u]=t;
    if (!son[u]) return;
    dfs(son[u], t);
    for (int i = h[u]; ~i; i = ne[i])
    {
        int j = e[i];
        if (j == fa[u] || j == son[u]) continue;
        dfs(j, j);
    }
}
void pushup(int u){
    tr[u].sum=tr[u<<1].sum+tr[u<<1|1].sum;
}
void pushdown(int u){
    auto &root=tr[u],&left=tr[u<<1],&right=tr[u<<1|1];
    if(root.add!=-1){
        left.add=root.add;
        left.sum=root.add*(left.r-left.l+1);
        right.add=root.add;
        right.sum=root.add*(right.r-right.l+1);
        root.add=-1;
    }
}
void build(int u,int l,int r){
    tr[u]={l,r,-1,0};
    if(l==r)return;
    int mid=l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    pushup(u);
}
void update(int u,int l,int r,int k){
    if (l <= tr[u].l && r >= tr[u].r)
    {
        tr[u].add = k;
        tr[u].sum = k * (tr[u].r - tr[u].l + 1);
        return;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid) update(u << 1, l, r, k);
    if (r > mid) update(u << 1 | 1, l, r, k);
    pushup(u);
}
void update_tree(int u,int k){
    update(1,id[u],id[u]+sz[u]-1,k);
}
void update_path(int u,int v,int k){
    while (top[u] != top[v])    //向上爬找到相同重链
    {
        if (dep[top[u]] < dep[top[v]]) swap(u, v);
        update(1, id[top[u]], id[u], k);    //dfs序原因，上面节点的id必然小于下面节点的id
        u = fa[top[u]];
    }
    if (dep[u] < dep[v]) swap(u, v);
    update(1, id[v], id[u], k);
}
int main(){
    int n;
    scanf("%d",&n);
    memset(h,-1,sizeof h);
    for(int i=2;i<=n;i++){
        int p;
        scanf("%d",&p);
        p++;
        add(p,i);
        fa[i]=p;
    }
    dfs1(1,1);
    dfs(1,1);
    build(1, 1, n);
    int m;
    scanf("%d",&m);
    while(m--){
        char op[20];
        int x;
        scanf("%s%d",op,&x);
        x++;
        if(!strcmp(op,"install")){
            int t=tr[1].sum;
            update_path(1,x,1);
            printf("%d\n",tr[1].sum-t);
        }
        else{
            int t=tr[1].sum;
            update_tree(x,0);
            printf("%d\n",t-tr[1].sum);
        }
    }
}