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: Runtime Error)

#include<bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp> //required
#include <ext/pb_ds/tree_policy.hpp> //required

using namespace __gnu_pbds; 
using namespace std;

template <typename T> using ordered_set =  tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>; 
typedef long long  ll;
typedef vector<ll> VL;
typedef vector<int> VI;
typedef pair<ll,ll> PLL;
typedef pair<int,int> PII;
#define pb push_back

#define F first
#define S second
#define ALL(a) a.begin(),a.end()
#define fr(i,x,y) for(ll i=x;i<y;i++)
#define frr(i,x,y) for(ll i=x-1;i>=y;i--)
#define inf 10000000000000000
const ll mod=998244353;
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}

void solve()
{
    ll n,m,q;
    cin>>n>>m>>q;
    vector<pair<PLL,PLL>> arr;
    fr(i,0,q)
    {
        ll a,b,c,d;
        cin>>a>>b>>c>>d;
        arr.pb({{d,c},{a,b}});
    }
    sort(ALL(arr));
    ll ans=0;
    ll p=-1,v=-1;
    VL per(n+1,-1);
    reverse(ALL(arr));
    fr(i,0,q)
    {
        if(p==-1)
        {
            ans+=arr[i].F.F;
            per[arr[i].S.S]=m;
            per[arr[i].S.F]=m-arr[i].F.S;
            p=1;
        }
        else
        {
            ll fg=-1;
            if(per[arr[i].S.S]==-1&&per[arr[i].S.F]==-1)
            {
                fg=-1;
                ans+=arr[i].F.F;
                per[arr[i].S.S]=m;
                per[arr[i].S.F]=m-arr[i].F.S;
            }
            if(per[arr[i].S.S]==-1&&fg==-1)
            {
                fg=1;
                ans+=arr[i].F.F;
                per[arr[i].S.S]=per[arr[i].S.F]+arr[i].F.S;
                //per[arr[i].S.F]=m-arr[i].F.S;
            }
            if(per[arr[i].S.F]==-1&&fg==-1)
            {
                ans+=arr[i].F.F;
                //per[arr[i].S.S]=arr[i].F.S+1;
                per[arr[i].S.F]=per[arr[i].S.S]-arr[i].F.S;
            }
            if(fg==-1)
            {
                if(per[arr[i].S.S]-per[arr[i].S.F]==arr[i].F.S)
                {
                    ans+=arr[i].F.F;
                }
            }
        }
    }
    cout<<ans<<endl;
    return;
}
int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    ll t=1;
    //cin>>t;
    while(t--)
    {
        solve();
    }
    return 0;
}