#include<bits/stdc++.h>
#define cir(i,a,b) for(int i=a;i<b;++i)
using namespace std;
class segment{
private:
    struct node{
        node*ls,*rs;
        int w;
        node():ls(nullptr),rs(nullptr),w(0){}
        ~node(){
            if(ls) delete ls;
            if(rs) delete rs;
        }
    };
    node*root;
    auto update(node*&u,int l,int r,int p,int w){
        if(!u) u=new node();
        u->w=max(u->w,w);
        if(l==r) return;
        const auto mid=(l+r)/2;
        p-1<mid?update(u->ls,l,mid,p,w):
            update(u->rs,mid+1,r,p,w);
    }
    auto query(node*u,int l,int r,int ql,int qr){
        auto res=0;
        if(!u) return res;
        if(ql-1<l&&r-1<qr) return u->w;
        const auto mid=(l+r)/2;
        if(ql-1<mid) res=max(res,query(u->ls,l,mid,ql,qr));
        if(mid<qr) res=max(res,query(u->rs,mid+1,r,ql,qr));
        return res;
    }
    int n;
    auto dfs(node*u,int l,int r,vector<pair<int,int>>&a){
        if(!u) return;
        if(l==r) return a.push_back({l,u->w});
        const auto mid=(l+r)/2;
        dfs(u->ls,l,mid,a);
        dfs(u->rs,mid+1,r,a);
    }
public:
    auto update(int p,int w){
        update(root,0,n-1,p,w);
    }
    auto query(int l,int r){
        return query(root,0,n-1,l,r);
    }
    auto swap(segment&sg){
        auto lrt=root;
        root=sg.root;sg.root=lrt;
    }
    auto getelement(){
        vector<pair<int,int>> res;
        dfs(root,0,n-1,res);
        delete root;root=nullptr;
        return res;
    }
    segment(int _n):n(_n-1),root(nullptr){}
    ~segment(){if(root) delete root;}
};
vector<vector<int>> gr,tr;
vector<int> dfn,low,a,siz,fl,fg;
vector<segment> sgml,sgmg;
auto dfs(int u,int&cnt,int f=0)->void{
    dfn[u]=++cnt;siz[u]=1;
    for(auto&i:gr[u]) if(i!=f){
        dfs(i,cnt,u);siz[u]+=siz[i];
        tr[u].push_back(i);
    }
    low[u]=cnt;
}
auto dfsfx(int u,int&ans,const int n)->void{
    sort(tr[u].begin(),tr[u].end(),
        [](int a,int b){return siz[a]>siz[b];});
    bool hvy=true;
    for(auto&i:tr[u]){
        dfsfx(i,ans,n);
        if(hvy){
            sgml[u].swap(sgml[i]);
            sgmg[u].swap(sgmg[i]);
        }else{
            auto elsl=sgml[i].getelement();
            auto elsg=sgmg[i].getelement();
            for(auto&[c,w]:elsl){
                ans=max(ans,w+sgmg[u].query(c+1,n+7));
                if(c<a[u]) ans=max(ans,w+sgmg[u].query(a[u]+1,n+7)+1);
            }
            for(auto&[c,w]:elsg){
                ans=max(ans,w+sgml[u].query(0,c-1));
                if(c>a[u]) ans=max(ans,w+sgml[u].query(0,a[u]-1)+1);
            }
            for(auto&[c,w]:elsl){
                sgml[u].update(c,w);
            }
            for(auto&[c,w]:elsg){
                sgmg[u].update(c,w);
            }
        }
        hvy=false;
    }
    sgml[u].update(a[u],fl[u]);
    sgmg[u].update(a[u],fg[u]);
}
auto init(int n){
    gr.resize(n+1);dfn.resize(n+1);
    low.resize(n+1);a.resize(n+1);
    tr.resize(n+1);siz.resize(n+1);
    fl.resize(n+1);fg.resize(n+1);
    sgml.resize(n+1,segment(n+7));
    sgmg.resize(n+1,segment(n+7));
}
int main(){
    ios::sync_with_stdio(false),cin.tie(0);
    int n;cin>>n;init(n);
    map<int,int> id;
    cir(i,1,n+1) cin>>a[i],id.insert({a[i],0});
    [&](){
        auto c=0;
        for(auto&[w,x]:id) x=++c;
    }();
    cir(i,1,n+1) a[i]=id[a[i]];
    cir(i,0,n-1){
        int u,v;cin>>u>>v;
        gr[u].push_back(v);
        gr[v].push_back(u);
    }
    [](){auto c=0;dfs(1,c);}();
    [&](){
        map<int,vector<int>> nrx;
        cir(i,1,n+1) nrx[a[i]].push_back(i);
        segment sgl(n+7);
        for(auto&[ax,bx]:nrx){
            for(auto&u:bx) fl[u]=sgl.query(dfn[u],low[u])+1;
            for(auto&u:bx) sgl.update(dfn[u],fl[u]);
        }
    }();
    [&](){
        map<int,vector<int>,greater<int>> nrx;
        cir(i,1,n+1) nrx[a[i]].push_back(i);
        segment sgg(n+7);
        for(auto&[ax,bx]:nrx){
            for(auto&u:bx) fg[u]=sgg.query(dfn[u],low[u])+1;
            for(auto&u:bx) sgg.update(dfn[u],fg[u]);
        }
    }();
    auto ans=0;
    cir(u,1,n+1) ans=max({ans,fl[u],fg[u]});
    dfsfx(1,ans,n);
    cout<<ans<<'\n';
    return 0;
}