Counting Offspring(hdu3887)

Counting Offspring

Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2759    Accepted Submission(s): 956

Problem Description

You are given a tree, it’s root is p, and the node is numbered from 1 to n. Now define f(i) as the number of nodes whose number is less than i in all the succeeding nodes of node i. Now we need to calculate f(i) for any possible i.

 

Input

Multiple cases (no more than 10), for each case:
The first line contains two integers n (0<n<=10^5) and p, representing this tree has n nodes, its root is p.
Following n-1 lines, each line has two integers, representing an edge in this tree.
The input terminates with two zeros.

 

Output

For each test case, output n integer in one line representing f(1), f(2) … f(n), separated by a space.

 

Sample Input

15 7

7 10

7 1

7 9

7 3

7 4

10 14

14 2

14 13

9 11

9 6

6 5

6 8

3 15

3 12

0 0

思路：dfs序+线段树;

首先dfs序线性化，然后我们知道，如果某点是另个点的孩子节点，那么他必然在被另一个点的父亲节点所包括，所以从小到大查询[l[i],r[i]]区间的和，往线段树加点单点更新。复杂度n*log(n);

#include<stdio.h>
#include<algorithm>
#include<queue>
#include<stdlib.h>
#include<iostream>
#include<string.h>
#include<set>
#include<map>
#include<vector>
using namespace std;
typedef long long LL;
typedef vector<int>Ve;
vector<Ve>vec(100005);
bool flag[100005];
int l[100005];
int r[100005];
int id[100005];
int cn = 0;
void dfs(int n);

int tree[100005*4];
void up(int l,int r,int k,int nn,int mm);
int ask(int l,int r,int k,int nn,int mm);
int main(void)
{
    int n,p;
    while(scanf("%d %d",&n,&p),n!=0&&p!=0)
    {   cn = 0;
        for(int i = 0;i < 100005;i++)
            vec[i].clear();
        memset(flag,0,sizeof(flag));
        for(int i = 0;i < n-1;i++)
        {
            int x,y;
            scanf("%d %d",&x,&y);
            vec[x].push_back(y);
            vec[y].push_back(x);
        }
        dfs(p);
        memset(tree,0,sizeof(tree));
        for(int i = 1;i <= n;i++)
        {
            if(i == 1)
                printf("%d",ask(l[i],r[i],0,1,cn));
                else printf(" %d",ask(l[i],r[i],0,1,cn));
            up(l[i],l[i],0,1,cn);
        }
        printf("
");
    }
    return 0;
}
void dfs(int n)
{
    flag[n] = true;
    l[n] = ++cn;
    for(int i = 0;i < vec[n].size();i++)
    {
        int d = vec[n][i];
        if(!flag[d])
            dfs(d);
    }r[n] = cn;
}
void up(int l,int r,int k,int nn,int mm)
{
    if(l > mm||r < nn)
    {
        return ;
    }
    else if(l <= nn&&r >= mm)
    {
        tree[k]++;return ;
    }
    up(l,r,2*k+1,nn,(nn+mm)/2);
    up(l,r,2*k+2,(nn+mm)/2+1,mm);
    tree[k] = tree[2*k+1]+tree[2*k+2];
}
int ask(int l,int r,int k,int nn,int mm)
{
    if(l > mm||r < nn)
    {
        return 0;
    }
    else if(l <= nn&&r >= mm)
    {
        return tree[k];
    }
    else
    {
        int nx = ask(l,r,2*k+1,nn,(nn+mm)/2);
        int ny = ask(l,r,2*k+2,(nn+mm)/2+1,mm);
        return nx + ny;
    }
}

 

Sample Output

0 0 0 0 0 1 6 0 3 1 0 0 0 2 0