#include <bits/stdc++.h>

using namespace std;
using ll = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, k;
    cin >> n >> k;

    vector<vector<int>> adj(n);
    vector<int> parent(n), jump(n), tin(n), tout(n), anc(k), col(n), depth(n);

    for (int i = 1; i < n; ++i) {
        int a, b;
        cin >> a >> b;
        a -= 1, b -= 1;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }

    for (int i = 0; i < n; ++i) {
        cin >> col[i];
        --col[i];
        anc[col[i]] = i;
    }

    auto dfs = [&](auto self, int v) -> void {
        static int T = 0;
        tin[v] = T++;

        for (int to : adj[v]) {
            if (to != parent[v]) {
                parent[to] = v;
                depth[to] = depth[v] + 1;
                int p = jump[v], pp = jump[p];
                if (depth[pp] - depth[p] == depth[p] - depth[v]) {
                    jump[to] = pp;
                } else {
                    jump[to] = v;
                }
                self(self, to);
            }
        }

        tout[v] = T;
    };

    dfs(dfs, 0);

    auto isp = [&](int x, int y) {
        return tin[x] <= tin[y] && tout[x] >= tout[y];
    };

    auto lca = [&](int x, int y) {
        while (!isp(x, y)) {
            if (!isp(jump[x], y)) {
                x = jump[x];
            } else {
                x = parent[x];
            }
        }
        return x;
    };

    for (int i = 0; i < n; ++i) {
        anc[col[i]] = lca(anc[col[i]], i);
    }

    vector<int> fa(n);
    iota(fa.begin(), fa.end(), 0);

    auto leader = [&](int x) {
        while (x != fa[x]) {
            x = fa[x] = fa[fa[x]];
        }
        return x;
    };

    auto unite = [&](int x, int y) {
        fa[leader(y)] = leader(x);
    };

    for (int i = 0; i < n; ++i) {
        if (i != anc[col[i]]) {
            int x = leader(i), c = anc[col[i]];
            while (!isp(x, c)) {
                unite(parent[x], x);
                x = leader(x);
            }
        }
    }

    vector<set<int>> st(n);

    auto addEdge = [&](int x, int y) {
        if (x == y) {
            return;
        }
        st[x].insert(y);
        st[y].insert(x);
    };

    for (int i = 1; i < n; ++i) {
        addEdge(leader(i), leader(parent[i]));
    }

    int cnt = 0;

    for (int i = 0; i < n; ++i) {
        if (leader(i) == i && st[i].size() <= 1) {
            cnt += 1;
        }
    }

    cout << cnt - 1 << '\n';

    return 0;
}