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;
}