Problem:
Score : 600 points

Problem Statement

We have a tree with N vertices, whose i-th edge connects Vertex u_i and Vertex v_i.
Vertex i has an integer a_i written on it.
For every integer k from 1 through N, solve the following problem:

We will make a sequence by lining up the integers written on the vertices along the shortest path from Vertex 1 to Vertex k, in the order they appear. Find the length of the longest increasing subsequence of this sequence.

Here, the longest increasing subsequence of a sequence A of length L is the subsequence A_{i_1} , A_{i_2} , ... , A_{i_M} with the greatest possible value of M such that 1 \leq i_1 < i_2 < ... < i_M \leq L and A_{i_1} < A_{i_2} < ... < A_{i_M}.

Constraints

2 \leq N \leq 2 \times 10^5

1 \leq a_i \leq 10^9

1 \leq u_i , v_i \leq N

u_i \neq v_i

The given graph is a tree.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 ... a_N
u_1 v_1
u_2 v_2
:
u_{N-1} v_{N-1}

Output

Print N lines. The k-th line, print the length of the longest increasing subsequence of the sequence obtained from the shortest path from Vertex 1 to Vertex k.

Sample Input 1

10
1 2 5 3 4 6 7 3 2 4
1 2
2 3
3 4
4 5
3 6
6 7
1 8
8 9
9 10

Sample Output 1

1
2
3
3
4
4
5
2
2
3

For example, the sequence A obtained from the shortest path from Vertex 1 to Vertex 5 is 1,2,5,3,4. Its longest increasing subsequence is A_1, A_2, A_4, A_5, with the length of 4.

Solution in C++ (GCC 9.2.1) (judge verdict: Wrong Answer)

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

struct Node{
    vector<ll> connections;

    void add(ll n){
        connections.push_back(n);
    }
};
vector<ll> A;
vector<ll> LIS;
vector<Node> Nodes;
vector<ll> ANS;

void solve(ll n, ll p, ll lis_r){
    // update ANS, LIS
    // back LIS
    ll update_index, previous_value;
    if(p==-1){
        update_index = 0ll;
        previous_value = LIS[0];
        LIS[0] = 1ll;
        lis_r = 0ll;
    }else{
        if(LIS[lis_r] < A[n]){
            lis_r++;
            update_index = lis_r;
            previous_value = LIS[lis_r];
            LIS[lis_r] = A[n];
        }else{
            update_index = lower_bound(LIS.begin(), LIS.end(), A[n]) - LIS.begin();
            previous_value = LIS[update_index];
            LIS[update_index] = A[n];
        }
    }
    ANS[n] = lis_r;
    Node node = Nodes[n];
    for(ll i=0ll;i<node.connections.size();i++){
        ll child = node.connections[i];
        if (child == p){
            continue;
        }
        solve(child, n, lis_r);
    }
    // back
    LIS[update_index] = previous_value;
}

int main(void)
{
    ll N;
    cin >> N;
    vector<ll> a(N);
    for(ll i=0;i<N;i++){
        cin >> a.at(i);
    }
    A = a;
    vector<ll> lis(N, LLONG_MAX);
    LIS = lis;
    vector<Node> nodes(N, Node());
    for(ll i=0;i<N-1;i++){
        ll v, u;
        cin >> u >> v;
        u--;
        v--;
        nodes[u].add(v);
        nodes[v].add(u);
    }
    Nodes = nodes;
    vector<ll> ans(N, 0);
    ANS = ans;
    solve(0, -1, -1);
    for(ll i=0;i<N;i++){
        cout << ANS[i] + 1 << endl;
    }
    return 0;
}