#include <fstream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <set>
using namespace std;

ifstream F("guvern.in");
ofstream G("guvern.out");

const int oo = 1<<30;
const int Nmax = 200010;

typedef pair<int,int> Pair;

#define IT(type) vector<type>::iterator
#define ST set<int,s_cmp>::iterator

int N,Out;

vector<int> V[Nmax],T[Nmax];
vector<Pair> St;

int A[Nmax],P[Nmax];
int Now[Nmax],Act;
int D[Nmax],Up[Nmax];

int Mark[Nmax];

struct v_cmp
{
    bool operator () (const int& a, const int& b)
    {
        return A[a] < A[b];
    }
};

struct s_cmp
{
    bool operator () (const int& a, const int& b)
    {
        return a < b;
    }
};

set<int,s_cmp> Set;

void Get(int Nod)
{
    Mark[Nod] = 1;
    Now[Nod] = ++Act;

    ST st = Set.lower_bound( A[Nod] );
    Up[Nod] = P[ (st == Set.end() ? 0 : *st) ];

    Set.insert( A[Nod] );

    for (IT(int) it = V[Nod].begin(); it != V[Nod].end(); ++it)
        if ( Mark[*it] == 0 )
            Get( *it );

    Set.erase( Set.find( A[Nod] ) );
}
void DFS(int Nod)
{
    Mark[Nod]=1;
    for (IT(int) it = V[Nod].begin(); it != V[Nod].end(); ++it)
        if ( !Mark[*it] )
            DFS(*it);

    D[Nod]=1;
    if ( T[Nod].size() )
        for (IT(int) it2 = T[Nod].begin(); it2 != T[Nod].end(); ++it2)
            D[Nod] += D[*it2];

    int Dad = Up[Nod], Sum = 0;
    while ( T[Dad].size() && Now[Nod] < Now[ T[Dad].back() ] )
    {
        Sum += D[ T[Dad].back() ];
        T[Dad].pop_back();
    }

    D[Nod] = max( D[Nod] , Sum );
    T[Dad].push_back(Nod);
}

int main()
{
    F>>N;
    for (int i=1,a,b;i<N;++i)
    {
        F>>a>>b;
        V[ a ].push_back( b );
        V[ b ].push_back( a );
    }
    for (int i=1;i<=N;++i)
    {
        F>>A[i];
        P[i]=i;
    }

    sort(P+1,P+N+1,v_cmp());
    for (int i=1;i<=N;++i)
        A[ P[i] ] = i;

    Get( 1 );

    memset(Mark,0,sizeof(Mark));
    DFS(1);

    for (int i = 1; i <= N; ++i)
        Out = max(Out,D[i]);
    G<<Out;
}