POJ -3321 Apple Tree（DFS序+树状数组）

题目链接：http://poj.org/problem?id=3321

题意：给你一棵初始时长满苹果的苹果树，有两种操作，
（1）将一个节点的状态改变（有苹果就把这个苹果去掉，没有就加一个）
（2）查询x及其子树一共有多少个苹果

思路：树上对子树的操作很麻烦，但是如果我们可以把树上操作转化为区间操作，那这一题就是一个单点更新，区间求和的题啦，那我们直接用树状数组（或者线段树）就可以直接求啦，但如何把树上问题转化为区间问题呢？可以考虑DFS序，对节点重新编号，每个节点进入的时间戳就是L，出去的时间戳就是R，之后就是树状数组的板子题啦。

AC代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>

using namespace std;

const int maxn=1e5+7;

int head[maxn<<1];
struct Edge
{
    int to,next;
}edge[maxn<<1];
int tot;

void init()
{
    memset(head,-1,sizeof(head));
    tot=0;
}

void addedge(int u,int v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}

int cnt,L[maxn],R[maxn];
bool book[maxn];

void DFS(int u)
{
    L[u]=++cnt;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].to;
        if(book[v]==0)
        {
            book[v]=1;
            DFS(v);
        }
    }
    R[u]=cnt;
}

int n,c[maxn];

int lowbit(int x)
{
    return x&(-x);
}

void update(int x,int val)
{
    for(int i=x;i<=n;i+=lowbit(i))
    {
        c[i]+=val;
    }
}

int query(int x)
{
    int ans=0;
    for(int i=x;i>0;i-=lowbit(i))
    {
        ans+=c[i];
    }
    return ans;
}

bool vis[maxn];

int main()
{
    while(~scanf("%d",&n))
    {
        init();
        for(int i=1;i<n;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            addedge(u,v);
            addedge(v,u);
        }

        memset(book,false,sizeof(book));
        cnt=0;
        book[1]=1;
        DFS(1);

        memset(c,0,sizeof(c));
        memset(vis,true,sizeof(vis));
        for(int i=1;i<=n;i++) update(i,1);
        int q;
        scanf("%d",&q);
        while(q--)
        {
            char ch;
            scanf(" %c",&ch);
            int x;
            scanf("%d",&x);
            if(ch=='C')
            {
                if(vis[x])
                {
                    update(L[x],-1);
                    vis[x]=false;
                }
                else
                {
                    update(L[x],1);
                    vis[x]=true;
                }
            }
            else
            {
                printf("%d\n",query(R[x])-query(L[x]-1));
            }
        }
    }
    return 0;
}