#include <bits/stdc++.h>


using namespace std;


#define ll long long
#define ld long double
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()


int n, k;
vector<vector<int>> g, occ;
vector<int> c, vis, sz, par, dep, in;
vector<int> l, r;
int tt = 0;


int centr = -1;
int ans = 1e9;


void build(int u, int p = 0) {
    l[u] = ++tt;
    for (auto v : g[u]) {
        if (v != p) {
            build(v, u);
        }
    }
    r[u] = tt;
}


void dfs(int u, int size, int p) {
    sz[u] = 1;
    par[u] = p;
    bool good = 1;
    for (auto v : g[u]) {
        if (v != p && !vis[v]) {
            dfs(v, size, u);
            sz[u] += sz[v];
            good &= (sz[v] <= size / 2);
        }
    }
    good &= (size - sz[u] <= size / 2);
    if (good == 1) {
        centr = u;
    }
}


vector<ll> f;


void add(int i, int x) {
    for (; i <= n; i += i & -i) {
        f[i] += x;
    }
}


void add(int l, int r, int x) {
    add(l, +x);
    add(r + 1, -x);
}


int get(int i) {
    int sum = 0;
    for (; i >= 1; i -= i & -i) {
        sum += f[i];
    }
    return sum;
}


void update_ans(int centr) {
    queue<int> q;
    for (auto x : occ[c[centr]]) {
        if (get(l[x]) > 0) {
            return;
        }
        q.push(x);
    }
    in[c[centr]] = 1;
    vector<int> revert;
    revert.push_back(c[centr]);
    int total = 1;
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        if (c[u] != c[par[u]] && in[c[par[u]]] == 0) {
            in[c[par[u]]] = 1;
            revert.push_back(c[par[u]]);
            total += 1;
            for (auto x : occ[c[par[u]]]) {
                if (get(l[x]) > 0) {
                    return;
                }
                q.push(x);
            }
        }
    }
    for (auto i : revert) {
        in[i] = 0;
    }
    ans = min(ans, total - 1);
}


void solve(int u, int p = 0) {
    centr = -1;
    dfs(u, 0, u);
    dfs(u, sz[u], u);
    par[centr] = centr;
    update_ans(centr);
    vis[centr] = 1;
    dep[centr] = dep[p] + 1;
    par[centr] = p;
    add(l[centr], r[centr], +1);
    int c = centr;
    for (auto v : g[u]) {
        if (!vis[v]) {
            solve(v, c);
        }
    }
    add(l[centr], r[centr], -1);
}


int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
	}
	cin >> n >> k;
    g.resize(n + 1);
    for (int i = 1; i < n; i += 1) {
        int a, b;
        cin >> a >> b;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    c.resize(n + 1);
    occ.resize(k + 1);
    in.resize(k + 1);
    for (int i = 1; i <= n; i += 1) {
        cin >> c[i];
        occ[c[i]].push_back(i);
    }
    l.resize(n + 1);
    r.resize(n + 1);
    f.resize(n + 1);
    build(1);
    vis.resize(n + 1);
    dep.resize(n + 1);
    par.resize(n + 1);
    sz.resize(n + 1);
    solve(1);
    cout << ans << "\n";
    return 0;
}