LOJ 2130 软件包管理器

熟练剖分

路径到根直接向上跳

#include <iostream>
#include <cassert>
#include <string>

using namespace std;

const int MAXN=101111;

int N, M;
int P;
string com;

struct Vert{
	int Fa, Son, Bro;
	int Size, Dep;
	int MainSon, Top;
	int Dps, Dpr;
} V[MAXN];

void DFS1(int at){
	V[at].Size=1;
	for(int to=V[at].Son;to>0;to=V[to].Bro){
		V[to].Dep=V[at].Dep+1;
		DFS1(to);
		V[at].Size+=V[to].Size;
		if(V[at].MainSon<=0 || V[to].Size>V[V[at].MainSon].Size)	V[at].MainSon=to;
	}
}

int Dfn[MAXN], DFN;

void DFS2(int at, int t){
	++DFN;
	Dfn[DFN]=at;V[at].Dps=DFN;
	V[at].Top=t;
	if(V[at].MainSon>0)	DFS2(V[at].MainSon, t);
	for(int to=V[at].Son;to>0;to=V[to].Bro){
		if(to==V[at].MainSon)	continue;
		DFS2(to, to);
	}
	V[at].Dpr=DFN;/**/
}

struct Node{
	int l, r;
	int Sum;
	int opt;
} T[MAXN<<2];

int L, R, op;
int Sum;

void BuildTree(int l, int r, int at){
	T[at].l=l;T[at].r=r;T[at].Sum=0;T[at].opt=-1;
	if(l<r){
		int m=(l+r)>>1;
		BuildTree(l, m, at<<1);
		BuildTree(m+1, r, (at<<1)|1);
	}
}

void opr(int at){
	T[at].Sum=op*(T[at].r-T[at].l+1);
}

void cop(int at){
	T[at].opt=op;
}

void pdw(int at){
	if(T[at].opt==-1)	return;
	int top=op;op=T[at].opt;
	opr(at<<1);cop(at<<1);
	opr((at<<1)|1);cop((at<<1)|1);
	op=top;T[at].opt=-1;
}

void pup(int at){
	T[at].Sum=T[at<<1].Sum+T[(at<<1)|1].Sum;
}

int Ask(int at){
	if(T[at].l>=L && T[at].r<=R){
		return T[at].Sum;
	}
	pdw(at);
	int m=(T[at].l+T[at].r)>>1;
	int ret=0;
	if(L<=m)	ret+=Ask(at<<1);
	if(R>m)	ret+=Ask((at<<1)|1);
	return ret;
}

void Update(int at){
	if(T[at].l>=L && T[at].r<=R){
		T[at].Sum=op*(T[at].r-T[at].l+1);
		T[at].opt=op;
		return;
	}
	pdw(at);
	int m=(T[at].l+T[at].r)>>1;
	if(L<=m)	Update(at<<1);
	if(R>m)	Update((at<<1)|1);
	pup(at);
}

int main(){
	ios_base::sync_with_stdio(false);
	
	cin >> N;
	for(int i=2, f;i<=N;++i){
		cin >> f;++f;
		V[i].Fa=f;V[i].Bro=V[f].Son;V[f].Son=i;
	}
	
	V[1].Dep=1;
	DFS1(1);
	DFS2(1, 1);
	
	assert(DFN==N);
	BuildTree(1, N, 1);
	
	cin >> M;
	while(M--){
		cin >> com >> P;++P;
		Sum=0;
		if(com[0]=='i'){
			op=1;
			for(int k=P;k>0;k=V[V[k].Top].Fa){
				L=V[V[k].Top].Dps;R=V[k].Dps;
				Sum+=Ask(1);
				Update(1);
			}
			cout << V[P].Dep-Sum << endl;
		}
		else{
			op=0;
			L=V[P].Dps;R=V[P].Dpr;
			Sum=Ask(1);
			Update(1);
			cout << Sum << endl;
		}
	}
	
	return 0;
}