#include <bits/stdc++.h>

using ll = long long;
using namespace std;

vector<int> g[200500];
int c[200500];
int d[200500];

int find_deepest(int u, int p = -1) {
    int res = u;
    d[u] = 0;

    for (int v : g[u]) {
        if (v != p) {
            int cur = find_deepest(v, u);
            d[cur] += 1;

            if (d[cur] > d[res]) {
                res = cur;
            }
        }
    }

    return res;
}

int dp[200500];

void set_deep(int u, int p = -1) {
    if (p == -1) {
       dp[u] = d[u] = 0;
    }

    for (int v : g[u]) {
        if (v != p) {
            dp[v] = d[v] = d[u] + 1;
            set_deep(v, u);
            dp[u] = max(dp[u], dp[v]);
        }
    }

    for (int &v : g[u]) {
        if (v == p) {
            swap(g[u].back(), v);
            break;
        }
    }

    sort(g[u].begin(), g[u].end() - (p != -1), [](int u, int v) {
        return dp[u] > dp[v];
    });
}

pair<int, int> ans[200500];

vector<int> path;
set<int> pos[200500];

int cnt = 0;

bool remove(int v) {
    if (pos[c[v]].contains(d[v]))  {
        pos[c[v]].erase(d[v]);
        if (pos[c[v]].empty()) {
            cnt -= 1;
        }
        return true;
    } else {
        return false;
    }
}

void add(int v) {
    if (!pos[c[v]].contains(d[v])) {
        pos[c[v]].insert(d[v]);
        if (pos[c[v]].size() == 1) {
            cnt += 1;
        }
    }
}

void dfs(int u, int p = -1) {
    int mx1 = 0;
    int mx2 = 0;

    if (g[u].size() >= 1 && g[u][0] != p) {
        mx1 = dp[g[u][0]] - d[u];
    }

    if (g[u].size() >= 2 && g[u][1] != p) {
        mx2 = dp[g[u][1]] - d[u];
    }

    vector<int> removed;

    for (int i = d[u] - 1; i >= d[u] - mx2 && i >= 0; i--) {
        int v = path[i];
        if (remove(v)) {
        }
    }

    path.push_back(u);
    add(u);

    if (mx1 != 0) {
        dfs(g[u].front(), u);
    }

    for (int i = min(d[u] - 1, d[u] - mx2); i >= d[u] - mx1 && i >= 0; i--) {
        int v = path[i];
        if (remove(v)) {
        }
    }

    for (int v : g[u]) {
        if (v != p && v != g[u].front()) {
            add(u);
            dfs(v, u);
        }
    }

    path.pop_back();
    remove(u);

    if (ans[u] == make_pair(0, 0)) {
        ans[u] = make_pair(d[u], cnt);
    } else if (d[u] > ans[u].first) {
        ans[u] = make_pair(d[u], cnt);
    }
}

signed main() {
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#else
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
#endif

    int n, m;
    cin >> n >> m;

    if (n == 2) {
        cout << "1\n1\n";
        return 0;
    }

    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;

        g[u].push_back(v);
        g[v].push_back(u);
    }

    for (int u = 1; u <= n; u++) {
        cin >> c[u];
    }

    int d1 = find_deepest(1);
    int d2 = find_deepest(d1);

    set_deep(d1);
    dfs(d1);

    set_deep(d2);
    dfs(d2);

    for (int u = 1; u <= n; u++) {
        cout << ans[u].second << '\n';
    }
    return 0;
}