#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using ll = long long;
const int INF = 1e9, MOD = 1e9 + 7;
void solve();
signed main() {
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
int q = 1;
while (q--) {
solve();
}
}
vector<vector<ll>> g;
vector<ll> val;
vector<ll> fl;
vector<vector<ll>> up, mx;
vector<ll> tin, tout;
ll timer = 1;
void ups(ll v, ll p) {
up[v][0] = p;
mx[v][0] = max(val[v], val[p]);
tin[v] = timer++;
for (int i = 1; i < 20; i++) {
up[v][i] = up[up[v][i - 1]][i - 1];
mx[v][i] = max(mx[v][i - 1], mx[up[v][i - 1]][i - 1]);
}
for (auto u: g[v]) {
if (u != p) {
fl[u] = fl[v] + 1;
ups(u, v);
}
}
tout[v] = timer++;
}
bool ch(ll a, ll b) {
return tin[a] <= tin[b] && tout[a] >= tout[b];
}
ll lc(ll a, ll b) {
if (ch(a, b)) return a;
if (ch(b, a)) return b;
for (int i = 19; i >= 0; i--) {
ll v = up[a][i];
if (ch(v, b)) continue;
a = v;
}
return up[a][0];
}
ll gt(ll a, ll ds) {
ll ans = val[a];
for (ll i = 19; i >= 0; i--) {
if (ds - (1 << i) >= 0) {
ans = max(ans, mx[a][i]);
ds -= (1 << i);
a = up[a][i];
}
}
return ans;
}
pair<ll, ll> clc(ll a, ll b) {
ll lca = lc(a, b);
ll dist = fl[a] + fl[b] - 2 * fl[lca];
ll m = max(gt(a, fl[a] - fl[lca]), gt(b, fl[b] - fl[lca]));
return {dist, m};
}
vector<ll> sz, par, used, lev;
vector<vector<ll>> ds, num;
vector<vector<ll>> l, r;
void get_sz(ll v, ll p) {
sz[v] = 1;
for (auto u: g[v]) {
if (u == p || used[u]) continue;
get_sz(u, v);
sz[v] += sz[u];
}
}
ll Find_centroid(ll v, ll p, ll all) {
ll next = -1;
for (auto u: g[v]) {
if (u == p || used[u]) continue;
if (sz[u] > all / 2) next = u;
}
if (next == -1) return v;
return Find_centroid(next, v, all);
}
vector<vector<ll>> cnt;
void calc(ll v, ll p, ll f, ll lv, ll lf, ll rf, ll c, ll &id) {
ds[lv][v] = f;
num[lv][v] = id++;
l[lv][v] = lf;
r[lv][v] = rf;
cnt[c].push_back(-INF);
for (auto u: g[v]) {
if (u == p || used[u]) continue;
calc(u, v, f + 1, lv, lf, rf, c, id);
}
}
void build(ll v, ll p, ll level) {
get_sz(v, -1);
v = Find_centroid(v, -1, sz[v]);
lev[v] = level;
par[v] = p;
used[v] = 1;
get_sz(v, -1);
ll id = 1;
ds[level][v] = 0;
num[level][v] = 0;
cnt[v].push_back(-INF);
for (auto u: g[v]) {
if (used[u]) continue;
calc(u, -1, 1, level, id, id + sz[u] - 1, v, id);
}
for (auto u: g[v]) {
if (!used[u]) build(u, v, level + 1);
}
}
vector<ll> p;
vector<vector<ll>> del;
void upd(ll c, ll v, ll x) {
if (c == -1) return;
if (!del[lev[c]][v]) {
cnt[c][num[lev[c]][v]] = max(cnt[c][num[lev[c]][v]], x + ds[lev[c]][v]);
}
upd(par[c], v, x);
}
void dfs(ll v, ll c) {
ll lv = lev[c];
del[lv][v] = 1;
cnt[c][num[lv][v]] = -INF;
for (auto u: g[v]) {
if (lev[u] < lev[c]) continue;
if (ds[lv][u] < ds[lv][v]) continue;
if (del[lv][u]) continue;
dfs(u, c);
}
}
void deleted(ll c, ll v) {
if (c == -1) return;
dfs(v, c);
deleted(par[c], v);
}
void get(ll c, ll v, ll &ans) {
if (c == -1) return;
auto [d, m] = clc(c, v);
if (m > val[v]) {
get(par[c], v, ans);
return;
}
if (v == c) {
for (ll j = 0; j < cnt[c].size(); j++) {
ans = max(ans, cnt[c][j]);
}
get(par[c], v, ans);
return;
}
for (ll j = 0; j < l[lev[c]][v]; j++) {
ans = max(ans, d + cnt[c][j]);
}
for (ll j = r[lev[c]][v] + 1; j < cnt[c].size(); j++) {
ans = max(ans, d + cnt[c][j]);
}
get(par[c], v, ans);
}
void solve() {
ll n;
cin >> n;
p.resize(n), val.resize(n);
for (int i = 0; i < n; i++) {
cin >> val[i];
val[i]--;
p[val[i]] = i;
}
g.resize(n);
for (int i = 1; i < n; i++) {
ll a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
up.resize(n, vector<ll>(20));
mx.resize(n, vector<ll>(20));
fl.resize(n);
tin.resize(n), tout.resize(n);
ups(0, 0);
sz.resize(n), par.resize(n, -1),
used.resize(n), lev.resize(n);
ds.resize(20, vector<ll>(n));
num.resize(20, vector<ll>(n, -1));
l.resize(20, vector<ll>(n));
r.resize(20, vector<ll>(n));
del.resize(20, vector<ll>(n));
cnt.resize(n);
build(0, -1, 0);
vector<ll> dp(n, -INF);
dp[n - 1] = 0;
for (auto v: g[p[n - 1]]) {
upd(v, v, 1);
}
deleted(p[n - 1], p[n - 1]);
for (ll i = n - 2; i >= 0; i--) {
get(p[i], p[i], dp[i]);
for (auto v: g[p[i]]) {
upd(v, v, dp[i] + 1);
}
deleted(p[i], p[i]);
}
ll ans = 0;
for (int i = 0; i < n; i++) {
ans = max(ans, dp[i]);
}
cout << ans;
}
