#include <fstream>
#include <algorithm>
#include <set>
#include <vector>
#include <cstring>

using namespace std;

ifstream fin("guvern.in");
ofstream fout("guvern.out");

int N;
int nrord;
int pos[200005], where[200005], D[200005], P[200005], val[200005];
vector<int> V[200005], T[200005];
bool used[200005];
set<int> Set;

bool cmp(int i1, int i2)
{
    return val[i1] < val[i2];
}

void compute(int nod)
{
    used[nod] = true;
    pos[nod] = ++nrord;

    set<int>::iterator its = Set.lower_bound(val[nod]);

    int value = 0;
    if (its != Set.end())
        value = P[*its];
    where[nod] = value;

    Set.insert(val[nod]);

    for (vector<int>::iterator it = V[nod].begin(); it != V[nod].end(); ++it)
        if (!used[*it])
            compute(*it);

    Set.erase(Set.find(val[nod]));
}

void dfs(int nod)
{
    used[nod] = true;
    for (vector<int>::iterator it = V[nod].begin(); it != V[nod].end(); ++it)
        if (!used[*it])
            dfs(*it);

    D[nod] = 1;
    for (vector<int>::iterator it = T[nod].begin(); it != T[nod].end(); ++it)
        D[nod] += D[*it];

    int tata = where[nod], snow = 0;
    while (!T[tata].empty() && pos[nod] < pos[T[tata].back()])
    {
        snow += D[T[tata].back()];
        T[tata].pop_back();
    }

    D[nod] = max(D[nod], snow);
    T[tata].push_back(nod);
}

int main()
{
    fin >> N;
    for (int i = 1, nod1, nod2; i <= N - 1; ++i)
    {
        fin >> nod1 >> nod2;
        V[nod1].push_back(nod2);
        V[nod2].push_back(nod1);
    }

    for (int i = 1; i <= N; ++i)
    {
        fin >> val[i];
        P[i] = i;
    }
    sort(P + 1, P + N + 1, cmp);
    for (int i = 1; i <= N; ++i)
        val[P[i]] = i; // ordinea nodurilor
    compute(1);

    memset(used, false, sizeof(used));
    dfs(1);

    int result = 0;
    for (int i = 1; i <= N; ++i)
        result = max(result, D[i]);

    fout << result << '\n';

    fin.close();
    fout.close();
    return 0;
}