#include <bits/stdc++.h>
    
using namespace std;
    
typedef long long ll;

const int  N = 2e5 + 12, MOD = (int)1e9 + 7;

int n, k, par[N], p[N], r[N], tin[N], tout[N], timer, w[N], cl[N];
vector<int> g[N], c[N], G[N], Gr[N], f[N];

void dfs(int v, int pr = -1) {
    par[v] = pr;
    tin[v] = ++timer;
    for(int to:g[v]) if(to != pr){
        dfs(to, v);
    }
    tout[v] = ++timer;
}

bool vis[N];
vector<int> ord;
void dfs1(int v) {
    vis[v] = 1;
    for(int to:G[v]) {
        if(!vis[to]) {
            dfs1(to);
        }
    }
    ord.push_back(v);
}
int t = 1;
void dfs2(int v) {
    cl[v] = t;
    f[t].push_back(v);
    for(int to:Gr[v]) {
        if(!cl[to]) {
            dfs2(to);
        }
    }
}
vector<int> path(int v, int u) {
    vector<bool> us(n + 1, 0);
    vector<int> P(n + 1, 0);
    us[v] = 1;
    queue<int> q;
    q.push(v);
    while(!q.empty()) {
        int x = q.front();
        q.pop();
        for(int to:g[x]) {
            if(!us[to]) {
                us[to] = 1;
                P[to] = x;
                q.push(to);
            }
        }
    }
    vector<int> ret;
    while(u) {
        ret.push_back(w[u]);
        u = P[u];
    }
    return ret;
}
void test() {
    cin >> n >> k;
    for(int i = 1; i <= n - 1; i++) {
        int x, y;
        cin >> x >> y;
        g[x].push_back(y);
        g[y].push_back(x);
    }
    dfs(1);
    for(int i = 1; i <= n; i++) {
        int a;
        cin >> a;
        w[i] = a;
        c[a].push_back(i);
    }
    for(int i = 1; i <= k; i++) {
        if((int)c[i].size() == 1) {
            cout << 0 << '\n';
            return;
        }
        sort(c[i].begin(), c[i].end(), [&](int v, int u) {
            return tin[v] < tin[u];
        });
        for(int j = 1; j < (int)c[i].size(); j++) {
            vector<int> f = path(c[i][j - 1], c[i][j]);
            for(int r:f) {
                if(r != i) {
                    G[i].push_back(r);
                    Gr[r].push_back(i);
                }
            }
            // int v = c[i][j];
            // if(w[par[v]] != i) {
            //     G[i].push_back(w[par[v]]);
            //     Gr[w[par[v]]].push_back(i);
            // }
        }
    }

    for(int i = 1; i <= k; i++) {
        if(!vis[i]) {
            dfs1(i);
        }
    }
    reverse(ord.begin(), ord.end());

    for(int i:ord) {
        if(!cl[i]) {
            dfs2(i);
            t++;
        }
    }
    int res = k - 1;
    for(int i = 1; i < t; i++) {
        bool bad = 0;
        for(int j:f[i]) {
            for(int to:G[j]) {
                if(cl[to] != i) {
                    bad = 1;
                    break;
                }
            }
        }
        if(!bad) {
            res = min(res, (int)f[i].size() - 1);
        }
    } 
    cout << res << '\n';
}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0); 
    
    int t = 1; 
    // cin >> t;
    
    while(t--) 
        test();
    
    return 0;
}