#include <iostream>
#include <fstream>
#include <queue>
#include <bitset>
#define pb push_back

using namespace std;

ifstream f("guvern.in");
ofstream g("guvern.out");

queue<int>q;

int n, nod1, nod2, minime[200005], mini=0x3f3f3f3f,ind_mini, fata_cozii, maxim_in_grupa;

bitset<200005>nu_este_tata;
bitset<200005>in_queue;

struct nod{
    int grad_cooperare, inaltime;
}noduri[200005];

vector<int>graph[200005];

void parcurgere(int ind)
{
    q.push(ind);
    while (!q.empty())
    {
        int sus=q.front();
        q.pop();
        for (int &v:graph[sus])
        {
            if (noduri[v].inaltime==0)
            {
                nu_este_tata[sus]=1;
                noduri[v].inaltime=noduri[sus].inaltime+1;
                q.push(v);
            }
        }
    }

}

void parcurgere_sus(int ind)
{
    if (ind==1)
    {
        return;
    }
    for (auto &v:graph[ind])
    {
        if (noduri[v].inaltime==noduri[ind].inaltime-1)
        {
            if (noduri[v].grad_cooperare>=noduri[fata_cozii].grad_cooperare && noduri[v].grad_cooperare<mini)
            {
                mini=noduri[v].grad_cooperare;
                ind_mini=v;
            }
            parcurgere_sus(v);
        }
    }
}

void solve()
{
    while (!q.empty())
    {
        fata_cozii=q.front();
        nu_este_tata[fata_cozii]=1;
        in_queue[fata_cozii]=0;
        if (minime[fata_cozii]>maxim_in_grupa)
            maxim_in_grupa=minime[fata_cozii];
        q.pop();
        mini=0x3f3f3f3f;
        ind_mini=-1;
        parcurgere_sus(fata_cozii);
        if (ind_mini!=-1 && mini!=0x3f3f3f3f)
        {
            minime[ind_mini]+=minime[fata_cozii];
            if (!in_queue[ind_mini])
                {q.push(ind_mini);
                in_queue[ind_mini]=1;
                }
        }

    }
}

int main()
{
    f >> n;
    for (int i=1; i<n; ++i)
    {
        f >> nod1 >> nod2;
        graph[nod1].pb(nod2);
        graph[nod2].pb(nod1);
    }
    for (int i=1; i<=n; ++i)
    {
        f >> noduri[i].grad_cooperare;
    }
    noduri[1].inaltime=1;
    mini=0x3f3f3f3f;
    parcurgere(1);
    for (int i=1; i<=n; ++i)
    {
        minime[i]=1;
        if (!nu_este_tata[i])
        {

            q.push(i);
        }
    }
    solve();
    bool mai_e=false;
    do{
        mai_e=false;
        for (int i=1; i<=n; ++i)
        {
            if (!nu_este_tata[i])
            {
                mai_e=true;
                minime[i]=1;
                q.push(i);
            }
        }
        if(mai_e)
            solve();
    }while(mai_e==true);
    g << maxim_in_grupa;
    return 0;
}