[USACO10FEB]慢下来Slowing down

题目描述

Every day each of Farmer John's N (1 <= N <= 100,000) cows conveniently numbered 1..N move from the barn to her private pasture. The pastures are organized as a tree, with the barn being on pasture 1. Exactly N-1 cow unidirectional paths connect the pastures; directly connected pastures have exactly one path. Path i connects pastures A_i and B_i (1 <= A_i <= N; 1 <= B_i <= N).

Cow i has a private pasture P_i (1 <= P_i <= N). The barn's small door lets only one cow exit at a time; and the patient cows wait until their predecessor arrives at her private pasture. First cow 1 exits and moves to pasture P_1. Then cow 2 exits and goes to pasture P_2, and so on.

While cow i walks to P_i she might or might not pass through a pasture that already contains an eating cow. When a cow is present in a pasture, cow i walks slower than usual to prevent annoying her friend.

Consider the following pasture network, where the number between
parentheses indicates the pastures' owner.

        1 (3)        
       / \
  (1) 4   3 (5)
     / \   
(2) 2   5 (4)

First, cow 1 walks to her pasture:

        1 (3)        
       / \
  [1] 4*  3 (5)
     / \   
(2) 2   5 (4)

When cow 2 moves to her pasture, she first passes into the barn's
pasture, pasture 1. Then she sneaks around cow 1 in pasture 4 before
arriving at her own pasture.

        1 (3)
       / \
  [1] 4*  3 (5)
     / \   
[2] 2*  5 (4)

Cow 3 doesn't get far at all -- she lounges in the barn's pasture, #1.

        1* [3]
       / \
  [1] 4*  3 (5)
     / \   
[2] 2*  5 (4)

Cow 4 must slow for pasture 1 and 4 on her way to pasture 5:

        1* [3]
       / \
  [1] 4*  3 (5)
     / \   
[2] 2*  5* [4]

Cow 5 slows for cow 3 in pasture 1 and then enters her own private pasture:

        1* [3]
       / \
  [1] 4*  3*[5]
     / \   
[2] 2*  5* [4]

FJ would like to know how many times each cow has to slow down.

每天Farmer John的N头奶牛(1 <= N <= 100000，编号1…N)从粮仓走向他的自己的牧场。牧场构成了一棵树，粮仓在1号牧场。恰好有N-1条道路直接连接着牧场，使得牧场之间都恰好有一条路径相连。第i条路连接着A_i，B_i，(1 <= A_i <= N; 1 <= B_i <= N)。 奶牛们每人有一个私人牧场P_i (1 <= P_i <= N)。粮仓的门每次只能让一只奶牛离开。耐心的奶牛们会等到他们的前面的朋友们到达了自己的私人牧场后才离开。首先奶牛1离开，前往P_1；然后是奶牛2，以此类推。

当奶牛i走向牧场P_i时候，他可能会经过正在吃草的同伴旁。当路过已经有奶牛的牧场时，奶牛i会放慢自己的速度，防止打扰他的朋友。

FJ想要知道奶牛们总共要放慢多少次速度。

输入输出格式

输入格式：

* Line 1: Line 1 contains a single integer: N

* Lines 2..N: Line i+1 contains two space-separated integers: A_i and B_i

* Lines N+1..N+N: line N+i contains a single integer: P_i

输出格式：

* Lines 1..N: Line i contains the number of times cow i has to slow down.

输入输出样例

输入样例#1： 

5 
1 4 
5 4 
1 3 
2 4 
4 
2 
1 
5 
3 

输出样例#1： 

0 
1 
0 
2 
1 

---

一个牛到达它的目的地之后， 它的子树的值都会加一， 所以我们用树状数组维护差分序列， 然后就这样搞下去...

---

#include <iostream>
#include <cstdio>
using namespace std;
inline int read(){
    int res=0;char ch=getchar();
    while(!isdigit(ch))    ch=getchar();
    while(isdigit(ch)){res=(res<<3)+(res<<1)+(ch^48);ch=getchar();}
    return res;
}
const int N = 100005;
int n;
struct edge{
    int nxt, to;
}ed[N*2];
int head[N], cnt;
inline void add(int x, int y){
    ed[++cnt] = (edge){head[x], y};
    head[x] = cnt;
}
int p[N], tr[N]; 
int ans[N];
namespace BITree{
    #define lowbit(x) x & -x
    void upd(int x, int y)
    {
        while(x < N)
        {
            tr[x]+=y;
            x+=lowbit(x);
        }
    }
    int ask(int x)
    {
        int res=0;
        while(x != 0)
        {
            res+=tr[x];
            x-=lowbit(x);
        }
        return res;
    }
}

inline void dfs(int x, int fa){
    ans[p[x]] = BITree::ask(p[x]);
    BITree::upd(p[x], 1);
    for (register int i = head[x] ; i ; i = ed[i].nxt)
    {
        int to = ed[i].to;
        if (to == fa) continue;
        dfs(to, x);
    }
    BITree::upd(p[x], -1);
}

int main()
{
    n = read();
    for (register int i = 1 ; i < n ; i ++){
        int x = read(), y = read();
        add(x, y), add(y, x);
    }
    for (register int i = 1 ; i <= n ; i ++) p[read()] = i;
    dfs(1, 0);
    for (register int i = 1 ; i <= n ; i ++) printf("%d\n", ans[i]) ;
    return 0;
}