NOI 2015 day1 T2 软件包管理器



题目大意：

一共有n个软件，这些软件相互依赖。这种依赖关系共有n-1对。如果A依赖B，安装A时必须安装B，卸载B时必须卸载A。

现在输入软件间的依赖关系，询问安装或卸载一个软件一共会有几个软件受到影响。

题解：

很明显，这些软件可以构成一棵树。

安装A即为询问从A到根节点的路径中有多少软件未安装

卸载A即为询问以A为根节点的子树有多少软件已安装。

将安装的节点设为1，初始设为0

利用树链剖分模板就可以直接解决安装问题，（answer = depth[ i ]-sum）

如果卸载，由于一颗子树编号连续，也可以直接在线段树上求和或修改。

（比模板还简单）

代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<fstream>

#define MAXN 200010

using namespace std;

int n,cnt,wcnt;
int size[MAXN],w[MAXN],son[MAXN],prt[MAXN],vis[MAXN],dep[MAXN];
int d[MAXN],top[MAXN];

struct Edge
{
    int v;
    Edge *next;
}ep[3*MAXN],*h[MAXN];

void AddEdge(int u,int v)
{
    Edge *p=&ep[++cnt];
    p->v=v;p->next=h[u];h[u]=p;
    Edge *q=&ep[++cnt];
    q->v=u;q->next=h[v];h[v]=q;
}

void Input()
{
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        scanf("%d",&prt[i]);
        AddEdge(i,prt[i]);
    }
}

void Dfs_1(int u)
{
    int v,maxsize=0,maxson=0;
    vis[u]=1;
    size[u]=1;
    for(Edge *p=h[u];p;p=p->next)
        if(!vis[v=p->v])
        {
            dep[v]=dep[u]+1;
            
            Dfs_1(v);
            if(size[v]>maxsize) maxsize=size[v],maxson=v;
            size[u]+=size[v];
        }
    son[u]=maxson;
}

void Dfs_2(int u)
{
    vis[u]=1;
    int v=son[u];
    if(!vis[v] && v)
    {
        top[v]=top[u];
        w[v]=++wcnt;
        Dfs_2(v);
    }
    for(Edge *p=h[u];p;p=p->next)
        if(!vis[v=p->v])
        {
            top[v]=v;
            w[v]=++wcnt;
            Dfs_2(v);
        }
}

struct Node
{
    int left,right,sum,lazy;
    Node *lson,*rson,*parent;
}pool[3*MAXN],*root;

void Build_Tree(Node *p,int left,int right)
{
    int mid=(left+right)/2;
    p->left=left;
    p->right=right;
    if(left==right) return ;
    p->lson=&pool[++cnt];
    p->rson=&pool[++cnt];
    p->lson->parent=p;
    p->rson->parent=p;
    Build_Tree(p->lson,left,mid);
    Build_Tree(p->rson,mid+1,right);
}

void Change(Node *p,int left,int right,int lazy)
{
    if(p->left==left && p->right==right)
    {
        p->lazy=lazy;
        for(Node *t=p->parent;t;t=t->parent)
	    {
		    int lsum=t->lson->sum,rsum=t->rson->sum;
		    if(t->lson->lazy!=0)
		        lsum=(t->lson->lazy-1)*(t->lson->right - t->lson->left +1);
		    if(t->rson->lazy!=0)
		        rsum=(t->rson->lazy-1)*(t->rson->right - t->rson->left +1);
		    t->sum=lsum+rsum;
		}
        return ;
    }
    if(p->lazy)
    {
        p->lson->lazy=p->lazy;
        p->rson->lazy=p->lazy;
        p->lazy=0;
    }
    if(p->lson->right >= right) Change(p->lson,left,right,lazy);
    else if(p->rson->left <= left) Change(p->rson,left,right,lazy);
    else
    {
        Change(p->lson,left,p->lson->right,lazy);
        Change(p->rson,p->rson->left,right,lazy);
    }
}

int Query(Node *p,int left,int right)
{
    if(p->left==left && p->right==right)
    {
        if(p->lazy==0)
            return p->sum;
        else if(p->lazy==1)
            return 0;
        else return p->right-p->left+1;
    }
    if(p->lazy)
    {
        p->lson->lazy=p->lazy;
        p->rson->lazy=p->lazy;
    }
    if(p->lson->right >= right) return Query(p->lson,left,right);
    else if(p->rson->left <= left) return Query(p->rson,left,right);
    else
    {
        return Query(p->lson,left,p->lson->right)
        +Query(p->rson,p->rson->left,right);
    }
}

int Query_Tree(int a,int b)
{
    int x=top[a],y=top[b],sum=0;
    while(x!=y)
    {
	    if(dep[x]<dep[y]) swap(x,y),swap(a,b);
	    sum+=Query(root,w[x],w[a]);
	    a=prt[x],x=top[a];
	}
	if(dep[a]<dep[b]) swap(a,b);
	sum+=Query(root,w[b],w[a]);
	return sum;
}

int install(int a)
{
    int x=top[a];
    while(x!=0)
    {
    	Change(root,w[x],w[a],2);
    	a=prt[x],x=top[a];
    }
    Change(root,0,w[a],2);
}

char ch[30];

int main()
{
	root=&pool[0];
    Input();
    dep[0]=1;
    top[0]=0;
    Dfs_1(0);
    memset(vis,0,sizeof(vis));
    Dfs_2(0);
    cnt=0;
    Build_Tree(root,0,n-1);
    int qn,id;
    scanf("%d",&qn);
    for(int i=1;i<=qn;i++)
    {
    	scanf("%s%d",ch,&id);
    	if(ch[0]=='i') 
    	{
    		printf("%d\n",dep[id]-Query_Tree(id,0));
			install(id);
		}
    	else 
    	{
			printf("%d\n",Query(root,w[id],w[id]+size[id]-1));
			Change(root,w[id],w[id]+size[id]-1,1);
		}
    }
    return 0;
}