codeforces 877E. Danil and a Part-time Job (DFS序列+线段树)

传送门：codeforces 877E

题目大意：

有一颗树，树的每个节点有一盏灯，状态为亮或灭。现在可以进行以下两种操作：

1.pow x，将以 x 为根节点的子树（包括根节点）的所有节点的灯的状态都反转（亮变为灭，灭变为亮）。

2.get x，获取以 x 为根节点的子树（包括根节点）的亮灯数目。

前置技能：

线段树和延迟标记，不了解线段树的先去学习一下再来看这个题吧。自己也懒得再说线段树了……

思路：

原来这个题有种固定的解法，就是 DFS序列+线段树，第一次这种类型的题，好好 mark 一下，一开始是无脑深搜的，妥妥的TLE。

什么是 DFS序列+线段树呢？我的理解就是，对一棵树深搜会产生特定的序列，每一个子树的所有节点一定是连续的（想想为什么？）。所以可以用线段树维护这个序列，也就是维护树的每一棵子树。所以，线段树的第 i 个叶子节点对应的是 DFS序列中编号为 i 的节点。

我们会进行两种操作，一是对某个子树的所有节点进行反转，这会影响到该子树的父亲节点。二是求某个子树的亮灯节点个数。利用线段树和子树 DFS序列编号连续的特征，我们可在反转时进行很好的维护父亲节点，在求亮灯数时通过对区间的查询得出结果。

我们用 str[i] 和 ed[i] (也就是 start 和 end，但是 end 好像是保留字，会CE) 表示以节点 i 为根的子树的节点在 DFS 序列中的最小编号和最大编号。由于一定是从根开始深搜，所以最小编号一定是子树根的编号。这样就获得了每棵子树的范围。

线段树节点可以用结构体，有两个属性，f 表示以当前节点为根的子树的全部节点是否都反转，num是以当前节点为根的子树中亮灯的数目。

代码：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<vector>
#define N 200010
using namespace std;

int tol,st[N],ed[N];
vector<int> mp[N];

struct node
{ //线段树节点 
	int f,num; //f为延迟标记，表示是否反转，num为子树亮灯的数目 
} T[N*4];

void dfs(int u)
{ //参数：当前节点
	int i,v;
	st[u]=++tol; //记录以当前节点为根的子树的最小dfs序编号 
	for(i=0;i<mp[u].size();i++)
	{
		v=mp[u][i];
		dfs(v);
	}
	ed[u]=tol; //记录以当前节点为根的子树的最大dfs序编号
}

void pushup(int rt)
{
	T[rt].num=T[rt<<1].num+T[rt<<1|1].num;
}

void pushdown(int rt,int L,int R)
{ //延迟标记下传
	if(T[rt].f)
	{
		int m=(L+R)>>1;
		T[rt<<1].f^=1;
		T[rt<<1|1].f^=1;
		T[rt<<1].num=(m-L+1)-T[rt<<1].num;
		T[rt<<1|1].num=(R-m)-T[rt<<1|1].num;
		T[rt].f=0;
	}
}

void build(int rt,int L,int R)
{ //建树，参数：根节点，区间左右端点 
	T[rt].f=0;
	if(L==R)
	{
		T[rt].num=0;
		return;
	}
	int m=(L+R)>>1;	
	build(rt<<1,L,m);
	build(rt<<1|1,m+1,R);
	pushup(rt);
}

void update(int rt,int L,int R,int l,int r)
{ //更新，参数：根节点，当前区间左右端点，更新区间左右端点 
	if(l<=L&&R<=r)
	{ //反转后亮灯数为子树节点个数 - 亮灯数 
		T[rt].num=R-L+1-T[rt].num;
		T[rt].f^=1; //标记反转 
		return;
	}
	pushdown(rt,L,R);
	int m=(L+R)>>1;
	if(l<=m) update(rt<<1,L,m,l,r);
	if(r>m) update(rt<<1|1,m+1,R,l,r);
	pushup(rt);
}

int query(int rt,int L,int R,int l,int r)
{ //查询，参数：根节点，当前区间左右端点，查询区间左右端点
	int ans=0;
	if(l<=L&&R<=r) return T[rt].num; //返回区间亮灯数 
	pushdown(rt,L,R);
	int m=(L+R)>>1;
	if(l<=m) ans+=query(rt<<1,L,m,l,r);
	if(r>m) ans+=query(rt<<1|1,m+1,R,l,r);
	pushup(rt);
	return ans;
}

int main()
{
	int i,n,m,x,ans;
	char s[5];
	while(~scanf("%d",&n))
	{
		for(i=1;i<=n;i++) mp[i].clear();
		for(i=2;i<=n;i++)
		{ //输入树 
			scanf("%d",&x);
			//由于dfs时只可能从父亲节点到子孙节点，所以只存一次即可 
			mp[x].push_back(i);
		}
		tol=0;
		dfs(1); //获得dfs序列 
		build(1,1,n); //建树 
		for(i=1;i<=n;i++)
		{ //如果当前节点灯亮则更新 
			scanf("%d",&x);
			if(x) update(1,1,n,st[i],st[i]);
		}
		scanf("%d",&m);
		while(m--)
		{
			scanf("%s%d",s,&x);     
			if(strcmp(s,"pow")==0) 
			{
				//更新区间为以当前节点为根的子树
				update(1,1,n,st[x],ed[x]);
			}			
			else
			{   //查询区间为以当前节点为根的子树 
				ans=query(1,1,n,st[x],ed[x]);
				printf("%d\n",ans);
			}
		}
	}
	return 0;
}