【HDU 3887 Counting Offspring】 dfs序+树状数组

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3887

题目大意： 给你一颗n个节点的数，对于每个节点i，问你每个节点的子树中有多少个节点序列数小于i，求f[i]。

解题思路：

   用样例来说明，我们可以先深搜一遍，那么深搜得到的序列就是  7，3，15，15，12， 12， 3， 4， 4， 1， 1， 10， 14， 13， 13， 2， 2， 14， 10，……9， 7

   对这个序列进行分析可以发现，举例：3，15，15，12， 12， 3 ， 节点3中间的数就是它的子树序列。

  dfs打好序列后就对序列进行遍历一遍，开两个st[], sd[] 数组， 存每个节点开始和结束位置。接下来就是树状数组求和，注意这里要序列从大到小求和（也就是n-->1），求完后删掉对应位置的数，树状数组进行相应的更新操作。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;

const int maxn=100005;
vector<int>vt[maxn];
int bit[2*maxn];
int que[2*maxn];
int st[maxn];
int sd[maxn];
int f[maxn];
int n, rt, num;

void dfs(int u, int fa)
{
    que[++num]=u;
    for(int i=0; i<vt[u].size(); i++)
    {
        int v=vt[u][i];
        if(v==fa) continue;
        dfs(v,u);
    }
    que[++num]=u;
}

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

void cal(int x, int val)
{
    while(x<=num)
    {
        bit[x]+=val;
        x+=lowbit(x);
    }
}

int getsum(int x)
{
    int ans=0;
    while(x>0)
    {
        ans+=bit[x];
        x-=lowbit(x);
    }
    return ans;
}

int main()
{
    while(~scanf("%d%d",&n,&rt),n+rt)
    {
        for(int i=0; i<=n; i++)
            vt[i].clear();
        for(int i=1; i<n; i++)
        {
            int x, y;
            scanf("%d%d",&x,&y);
            vt[x].push_back(y);
            vt[y].push_back(x);
        }
        fill(st+1,st+1+n,0);
        num=0;
        dfs(rt,-1);
        for(int i=1; i<=num; i++)
        {
            if(!st[que[i]]) st[que[i]]=i;
            else sd[que[i]]=i;
        }
        memset(bit,0,sizeof(bit));
        for(int i=1; i<=num; i++)
            cal(i,1);
        for(int i=n; i>=1; i--)
        {
            f[i]=(getsum(sd[i]-1)-getsum(st[i]))/2;
            cal(st[i],-1);
            cal(sd[i],-1);
        }
        printf("%d",f[1]);
        for(int i=2; i<=n; i++)
            printf(" %d",f[i]);
        puts("");
    }
    return 0;
}