#include<bits/stdc++.h>
using namespace std;
    
#define FAST ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#include <ext/pb_ds/assoc_container.hpp> 
#include <ext/pb_ds/tree_policy.hpp> 
using namespace __gnu_pbds; 
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
    
#define int long long
#define double long double
    
#define all(a)      (a).begin(),(a).end()
#define sz(x)       (int)x.size()
    
#define ff first
#define ss second
#define mp make_pair
         
#define pb push_back
#define endl "\n" 
         
#define f(i,l,r) for(int i=l;i<=r;i++)
#define rf(i,r,l) for(int i=r;i>=l;i--)    

#define bp __builtin_popcountll
#define inf 3e15
    
const int NN=2e5+15;
const int M=1e9+7;
vector<int> g[NN];
int n;
int a[NN],b[NN];
struct dat
{
	//Use required attributes
	int mn;

	//Default Values
	dat() : mn(0) {};
};

struct SegTree
{
	int N;
	vector<dat> st;
	vector<bool> cLazy;
	vector<int> lazy;

	void init(int n)
	{
		N = n;
		st.resize(4 * N + 5);
		cLazy.assign(4 * N + 5, false);
		lazy.assign(4 * N + 5, 0);
	}

	//Write reqd merge functions
	void merge(dat &cur, dat &l, dat &r) 
	{
		cur.mn = max(l.mn, r.mn);
	}
	
	//Handle lazy propagation appriopriately
	void propagate(int node, int L, int R)
	{
		if(L != R)
		{
			cLazy[node*2] = 1;
			cLazy[node*2 + 1] = 1;
			lazy[node*2] = lazy[node];
			lazy[node*2 + 1] = lazy[node]; 
		}
		st[node].mn = lazy[node];
		cLazy[node] = 0;
	}

	void build(int node, int L, int R)
	{
		if(L==R)
		{
			st[node].mn = 0;
			return;
		}
		int M=(L + R)/2;
		build(node*2, L, M);
		build(node*2 + 1, M + 1, R);
		merge(st[node], st[node*2], st[node*2+1]);
	}

	dat Query(int node, int L, int R, int i, int j)
	{
		if(j<L || i>R)
			return dat();
		if(i<=L && R<=j)
			return st[node];
		int M = (L + R)/2;
		dat left=Query(node*2, L, M, i, j);
		dat right=Query(node*2 + 1, M + 1, R, i, j);
		dat cur;
		merge(cur, left, right);
		return cur;
	}

	dat pQuery(int node, int L, int R, int pos)
	{
		if(L == R)
			return st[node];
		int M = (L + R)/2;
		if(pos <= M)
			return pQuery(node*2, L, M, pos);
		else
			return pQuery(node*2 + 1, M + 1, R, pos);
	}	

	void Update(int node, int L, int R, int i, int j, int val)
	{
		if(j<L || i>R)
			return;
		if(i<=L && R<=j)
		{
			cLazy[node] = 1;
			lazy[node] = val;
			propagate(node, L, R);
			return;
		}
		int M = (L + R)/2;
		Update(node*2, L, M, i, j, val);
		Update(node*2 + 1, M + 1, R, i, j, val);
		merge(st[node], st[node*2], st[node*2 + 1]);
	}

	void pUpdate(int node, int L, int R, int pos, int val)
	{
		if(cLazy[node])
			propagate(node, L, R);
		if(L == R)
		{
			cLazy[node] = 1;
			lazy[node] = val;
			propagate(node, L, R);
			return;
		}
		int M = (L + R)/2;
		if(pos <= M)
			pUpdate(node*2, L, M, pos, val);
		else
			pUpdate(node*2 + 1, M + 1, R, pos, val);
		merge(st[node], st[node*2], st[node*2 + 1]);
	}

	dat query(int pos)
	{
		return pQuery(1, 1, N, pos);
	}

	dat query(int l, int r)
	{
		return Query(1, 1, N, l, r);
	}

	void update(int pos, int val)
	{
		pUpdate(1, 1, N, pos, val);
	}

	void update(int l, int r, int val)
	{
		Update(1, 1, N, l, r, val);
	}
};

map<int,int> mm,pp;
int ans[NN];
SegTree seg;
void dfs(int x,int p)
{
	for(auto X:g[x])
	{
		if(X!=p)
		{
			dat pp=seg.query(1,mm[a[X]]-1);
			dat old=seg.query(mm[a[X]],mm[a[X]]);
			int xx=pp.mn;
			// cout<<X<<" "<<xx<<endl;
			if(xx+1>ans[x])
			{
				ans[X]=xx+1;
			}
			else
			{
				ans[X]=ans[x];
			}
			if(xx+1>old.mn)
			seg.update(mm[a[X]],xx+1);
			dfs(X,x);
			seg.update(mm[a[X]],old.mn);
		}
	}
}
void solve()
{
	cin>>n;
	f(i,1,n) cin>>a[i],b[i]=a[i];
	sort(b+1,b+n+1);
	int cnt=0;
	f(i,1,n)
	{
		if(mm.find(b[i])==mm.end())
		{
			// cout<<b[i]<<" ";
			mm[b[i]]=++cnt;
			pp[cnt]=b[i];
		}
	}
	// cout<<mm[2]<<endl;
	f(i,1,n-1)
	{
		int t1,t2;
		cin>>t1>>t2;
		g[t1].pb(t2);
		g[t2].pb(t1);
	}
	seg.init(cnt+5);
	seg.build(1,1,cnt);
	seg.update(mm[a[1]],1);
	ans[1]=1;
	// cout<<mm[2]<<endl;
	// dat oo=seg.query(1,mm[2]-1);
	// cout<<oo.mn<<endl;
	dfs(1,0);
	f(i,1,n)
	{
		cout<<ans[i]<<endl;
	}
}
signed main()  
{
	FAST
    int t=1;
    // cin>>t;
    for(int tc=1;tc<=t;tc++)
    {
    	// cout<<"Case #"<<tc<<": ";
    	solve();
    }
}



Measured memory_bytes: 83084