题目链接

题目

题目描述

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 AiA_iAi and BiB_iBi (1 <= \(A_i\) <= N; 1 <= \(B_i\) <= N).
Cow i has a private pasture PiP_iPi (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.

输入描述

• 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 

输出

0
1
0
2
1

题解

知识点：DFS序，树状数组。

我们需要求，一个牛到他去的地方的路径上经过了几个已经有牛的地方。用树剖很容易解决路径查询、单点修改问题。但是这里用dfs序一样可以维护，只是我们需要将单点修改转换为对其子树答案的修改，即一个牛到达之后其子树的答案都会加 \(1\) ，查询就会变成单点查询。

时间复杂度 \(O(n \log n)\)

空间复杂度 \(O(n)\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

template<class T>
class Fenwick {
    int n;
    vector<T> node;

public:
    Fenwick(int _n = 0) { init(_n); }

    void init(int _n) {
        n = _n;
        node.assign(n + 1, T());
    }

    void update(int x, T val) { for (int i = x;i <= n;i += i & -i) node[i] += val; }

    T query(int x) {
        T ans = T();
        for (int i = x;i >= 1;i -= i & -i) ans += node[i];
        return ans;
    }
};

struct T {
    int sum;
    T &operator+=(const T &x) { return sum += x.sum, *this; }
};

const int N = 1e5 + 7;
vector<int> g[N];
int p[N];

int dfncnt;
int L[N], R[N];
void dfs(int u, int fa) {
    L[u] = ++dfncnt;
    for (auto v : g[u]) {
        if (v == fa) continue;
        dfs(v, u);
    }
    R[u] = dfncnt;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1;i <= n - 1;i++) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    for (int i = 1;i <= n;i++) cin >> p[i];

    dfs(1, 0);

    Fenwick<T> fw(n);
    for (int i = 1;i <= n;i++) {
        cout << fw.query(L[p[i]]).sum << '\n';
        fw.update(L[p[i]], { 1 });
        fw.update(R[p[i]] + 1, { -1 });
    }
    return 0;
}