poj 3321Apple Tree（树状数组+dfs映射）

Apple Tree

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 27505		Accepted: 8152

Description

There is an apple tree outside of kaka's house. Every autumn, a lot of apples will grow in the tree. Kaka likes apple very much, so he has been carefully nurturing the big apple tree.

The tree has N forks which are connected by branches. Kaka numbers the forks by 1 to N and the root is always numbered by 1. Apples will grow on the forks and two apple won't grow on the same fork. kaka wants to know how many apples are there in a sub-tree, for his study of the produce ability of the apple tree.

The trouble is that a new apple may grow on an empty fork some time and kaka may pick an apple from the tree for his dessert. Can you help kaka?

Input

The first line contains an integer N (N ≤ 100,000) , which is the number of the forks in the tree.
The following N - 1 lines each contain two integers u and v, which means fork u and fork v are connected by a branch.
The next line contains an integer M (M ≤ 100,000).
The following M lines each contain a message which is either
"C x" which means the existence of the apple on fork x has been changed. i.e. if there is an apple on the fork, then Kaka pick it; otherwise a new apple has grown on the empty fork.
or
"Q x" which means an inquiry for the number of apples in the sub-tree above the fork x, including the apple (if exists) on the fork x
Note the tree is full of apples at the beginning

Output

For every inquiry, output the correspond answer per line.

Sample Input

3
1 2
1 3
3
Q 1
C 2
Q 1

Sample Output

3
2

经过这题加深了对树状数组的认识~~感谢http://blog.csdn.net/zhang20072844/article/details/6703432

下面摘自http://blog.csdn.net/zhang20072844/article/details/6703432

给你一颗苹果树，树的主干设为1，每一个分支设为一个数，一直到N，代表这颗苹果树。每个分支上面只能最多有一个苹果，也就是一个枝子上面不可能有两个苹果，另外注意一点，不要把苹果树想象成二叉树，苹果树每个节点可以分出很多叉，应该是多叉树。
 
输入是叉之间的关系，
1 2
1 3
就是主干上面两个叉分别是2 和3.
 
下面是两种操作，Q 和C
C   j  的意思是如果 j 这个枝子上面有苹果就摘下来，如果没有，那么就会长出新的一个
Q  j  就是问 j 这个叉上面的苹果总数。
 
这个题很明显是线段树，其实我很多时候就用树状数组解决，但是，这个数组怎么来定？？？？？算法很容易搞定，但是初始化是问题。
先来说一下树状数组：
 
先看一个例题:
数列操作:
给定一个初始值都为0的序列,动态地修改一些位置上的数字,加上一个数,减去一个数,或者乘上一个数,然后动态地提出问题,问题的形式是求出一段数字的和.
若要维护的序列范围是0..5,先构造下面的一棵线段树:
 
 
 
可以看出,这棵树的构造用二分便可以实现.复杂度是2*N.
每个结点用数组a来表示该结点所表示范围内的数据之和.
修改一个位置上数字的值,就是修改一个叶子结点的值,而当程序由叶子结点返回根节点的同时顺便修改掉路径上的结点的a数组的值. 
对于询问的回答,可以直接查找i..j范围内的值,遇到分叉时就兵分两路,最后在合起来.也可以先找出0..i-1的值和0..j的值,两个值减一减就行了.后者的实际操作次数比前者小一些.
这样修改与维护的复杂度是logN.询问的复杂度也是logN,对于M次询问,复杂度是MlogN.
然而不难发现,线段树的编程复杂度大,空间复杂度大,时间效率也不高.
更好的解决办法就是用树状数组!
下图中的C数组就是树状数组,a数组是原数组
 
 
 
 
对于序列a，我们设一个数组C定义C[i] = a[i-2^k+1] + a[i-2^k+2] + … + a[i]，k为i在二进制下末尾0的个数。
2^k的计算可以这样:2^k = i & (i^(i-1)) 
若要求i..j的元素和的值，则求出 1~i-1和1~j的值，相减即可
在很多的情况下,线段树都可以用树状数组实现.凡是能用树状数组的一定能用线段树.当题目不满足减法原则的时候,就只能用线段树,不能用树状数组.例如数列操作如果让我们求出一段数字中最大或者最小的数字,就不能用树状数组了.
注：用数组保存静态一维线段数也可以不记录左右孩子的下标
如0号是根节点，其孩子是1、2；
1号的孩子是3、4；
2号的孩子是5、6；
3号的孩子是7、8；
……
n号的孩子是2*n+1、2*n+2。
再说说本题如何用树状数组来解决：
 
想必大家都明白上面说的了吧，就是为了快速的查询一个数组某一段的和，一旦这一段经过修改，依然快速给出答案。
而这个题不正是这个意思么，原先都是一个苹果，摘掉或者新长出，不就是改变数组的某个值么，这时候要查询的不就是某个区间的值么？
 
而上面的例子就是一个一维数组，但是现在如何把一个树转化为一维数组呢？这是这道题目的关键，否则没法做。
如果理解了这一点，就好办了。

对一棵树进行深搜，然后将深搜的顺序重新标上号，然后放到一个数组中，记下每一个枝子得起始点和终结点，然后就可以用树状数组了。
还是举个例子吧。。。

如果一棵苹果树是这样的。
 
那么我们知道1是主干。。。。
深搜的顺序是1 4 6 5 7 2 3 当然这也是根据题目的输入建的广义表。
那么当我们深搜的时候就可以在下面标上：
1 4 6 5 7 2 3 （广义表里面的东西，深搜结果）
1 2 3 4 5 6 7（num数组我们求和要用的）
这样不就是树状数组了么。
我们用start【1】= 1 end【1】=7代表1以上的树枝为1-7，也就是所有
用 start【2】= 6  end【2】 = 7 代表2以上的树枝是 3
同理
start【4】=2 end【4】 = 5 这样我们就知道4上面的树枝了
每一个树枝在num【n】总数组中的位置，这样我们就可以计算啦。。。树状数组，和上面将的一样了，成功转换
具体键代码，main函数主要建广义表，dfs主要是找到每一个树枝在num【n】数组中的起点和终点并记录在start和end数组中。
 
 

  
  
#include<stdio.h>
#include<string.h>
#define maxn 100005
#define lowbit(x) x&(-x)
int n,m,deep;
int head[maxn];
int low[maxn];
int high[maxn];
int vis[maxn];
int pick[maxn];
int c[maxn];
int cnt;
struct node
{
    int v,next;
}s[maxn];

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

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

void dfs(int u)
{
    vis[u] = 1;
    deep++;
    low[u] = deep;
    for( int i = head[u]; i!=-1; i = s[i].next)
    {
        int v = s[i].v;
        if(!vis[v])
        {
            dfs(v);
        }
    }
    high[u]=deep;
}
int main()
{
    int i, j, k;
    cnt = 0,deep = 0;
    memset(head, -1,sizeof(head));
    scanf("%d", &n);
    for( i = 1; i <= n-1; i++)
    {
        int u, v;
        scanf("%d%d", &u, &v);
        s[cnt].v=v;
        s[cnt].next = head[u];
        head[u]=cnt++;
    }
    dfs(1);
    for( i = 1; i <=n; i++)
        add(i, 1);
    scanf("%d", &m);
    while(m--)
    {
       char s[10];
       int c;
       scanf("%s%d", &s,&c);
       if(s[0] == 'C')
       {
          if(pick[c])
          {
              add(low[c],1);
              pick[c]=0;
          }
          else
          {
              add(low[c], -1);pick[c]=1;
          }
       }
       else
       {
           printf("%d\n", sum(high[c])-sum(low[c] - 1));
       }
    }

}