#include <bits/stdc++.h>

using namespace std;
using ll = long long;

#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
#define pb push_back
#define ff first
#define sc second

template<typename T>
struct sparsetable {
    int n;
    vector<T> arr;
    vector<vector<T>> sp;
    function<T(T, T)> comp;
    sparsetable() = default;
    sparsetable(int n_, vector<T> arr_, function<T(T, T)> f) {
        n = n_;
        arr = arr_;
        comp = f;
        build();
    }

    void build() {
        int lg = (int) log2(n) + 1;
        sp.assign(lg, vector<T>(n));
        for (int i = 0; i < n; i++) sp[0][i] = arr[i];
        for (int i = 1; i <= lg; i++) {
            for (int j = 0; j + (1 << i) - 1 < n; j++) {
                sp[i][j] = comp(sp[i - 1][j], sp[i - 1][j + (1 << (i - 1))]);
            }
        }
    }

    T get(int l, int r) {
        int lg = 31 - __builtin_clz(r - l + 1);
        return comp(sp[lg][l], sp[lg][r - (1 << lg) + 1]);
    }
};

const int LOGMAX = 20;

void solve() {
    int n, m; cin >> n >> m;
    vector<int> c(n);
    vector<vector<int>> g(n);
    for (int i = 0; i < n - 1; i++) {
        int u, v; cin >> u >> v;
        u--; v--;
        g[u].pb(v);
        g[v].pb(u);
    }
    for (int i = 0; i < n; i++) cin >> c[i];

    vector<int> tin(n), tout(n);
    vector<int> hs, vts, h(n);
    auto dfs0 = [&](int v, int p, auto&&self) -> void {
        tin[v] = sz(hs);
        hs.pb(h[v]);
        vts.pb(v);
        for (auto &u : g[v]) {
            if (u != p) {
                h[u] = h[v] + 1;
                self(u, v, self);
                hs.pb(h[v]);
                vts.pb(v);
            }
        }
        tout[v] = sz(hs) - 1;
    };
    dfs0(0, 0, dfs0);
    vector<pair<int, int>> lol;
    for (int i = 0; i < sz(hs); i++) lol.pb({hs[i], i});
    sparsetable<pair<int, int>> sp(sz(hs), lol, [](pair<int, int> x, pair<int, int> y) {
        return (x.first < y.first ? x : y);
    });
    vector<int> vt_num(3 * n, -1);

    auto is_par = [&](int v, int u) {
        return tin[v] <= tin[u] && tout[u] <= tout[v];
    };
    auto lca = [&](int u, int v) {
        if (is_par(u, v)) return u;
        if (is_par(v, u)) return v;
        auto rs = sp.get(min(tout[v], tout[u]), max(tin[v], tin[u]));
        return vts[rs.second];
    };
    auto dist = [&](int u, int v) {
        if (u >= n) u = vt_num[u];
        if (v >= n) v = vt_num[v];
        return h[u] + h[v] - 2 * h[lca(u, v)];
    };

    vector<int> nxt(3 * n);
    vector<vector<int>> up(LOGMAX, vector<int>(3 * n, -1));
    vector<int> maxd(n);

    auto jump = [&](int vt, int v, int maxd) {
        if (vt == -1) return -1;
        // find min jump from vt in graph nxt, where dist(v, jump) > maxd
        for (int i = LOGMAX - 1; i >= 0; i--) {
            if (up[i][vt] != -1 && dist(v, up[i][vt]) <= maxd) {
                vt = up[i][vt];
            }
        }
        if (vt != -1 && dist(v, vt) > maxd) return vt;
        if (up[0][vt] != -1) return up[0][vt];
        return (dist(v, vt) > maxd ? vt : -1);
    };

    auto dfs1 = [&](int v, int p, auto&&self) -> void {
        maxd[v] = h[v];
        vector<int> sons;
        for (auto &u : g[v]) {
            if (u != p) {
                self(u, v, self);
                sons.pb(u);
            }
        }
        if (sons.empty()) {
            nxt[v] = -1;
            up[0][v] = nxt[v];
            for (int i = 1; i < LOGMAX; i++) {
                if (up[i - 1][v] == -1) up[i][v] = -1;
                else {
                    up[i][v] = up[i - 1][up[i - 1][v]];
                }
            }
            return;
        }
        int bs = sons[0];
        for (int i = 1; i < sz(sons); i++) {
            if (maxd[sons[i]] > maxd[bs]) bs = sons[i];
        }
        int md2 = 0;
        for (int son : sons) {
            if (son != bs) md2 = max(md2, maxd[son] - h[v]);
        }
        nxt[v] = jump(bs, v, md2);
        up[0][v] = nxt[v];
        maxd[v] = maxd[bs];
        for (int i = 1; i < LOGMAX; i++) {
            if (up[i - 1][v] == -1) up[i][v] = -1;
            else {
                up[i][v] = up[i - 1][up[i - 1][v]];
            }
        }
    };

    dfs1(0, 0, dfs1);
    vector<int> final_vertex(n);
    int curvts = 0;
    auto dfs2 = [&](int v, int p, int pvert, int upp, auto&&self) -> void {
        if (maxd[v] - h[v] > upp) final_vertex[v] = jump(v, v, upp);
        else {
            final_vertex[v] = jump(pvert, v, maxd[v] - h[v]);
        }

        vector<int> sons;
        for (auto &u : g[v]) {
            if (u != p) sons.pb(u);
        }
        if (sons.empty()) {
            return;
        }
        sort(all(sons), [&](int i, int j) {
            return maxd[i] > maxd[j];
        });
        if (sons.size() == 1) {
            int nv = n + curvts;
            vt_num[nv] = v;
            nxt[nv] = pvert;
            up[0][nv]=nxt[nv];
            for (int i = 1; i < LOGMAX; i++) {
                up[i][nv] = (up[i - 1][nv] == -1 ? -1 : up[i - 1][up[i - 1][nv]]);
            }

            curvts++;
            self(sons[0], v, nv, upp + 1, self);
            return;
        }
        for (int i = 0; i < sz(sons); i++) {
            int vt2 = (i == 0 ? sons[1] : sons[0]);
            int nv = n + curvts;
            vt_num[nv] = v;
            curvts++;
            if (maxd[vt2] - h[v] > upp) {
                nxt[nv] = jump(vt2, v, upp);
            } else {
                nxt[nv] = jump(pvert, v, maxd[vt2] - h[v]);
            }

            up[0][nv]=nxt[nv];
            for (int i = 1; i < LOGMAX; i++) {
                up[i][nv] = (up[i - 1][nv] == -1 ? -1 : up[i - 1][up[i - 1][nv]]);
            }
            self(sons[i], v, nv, max(upp, maxd[vt2] - h[v]) + 1, self);
        }
    };
    dfs2(0, 0, -1, 0, dfs2);
    vector<vector<int>> G(3 * n);
    for (int i = 0; i < 3 * n; i++) {
        if (nxt[i] != -1) G[nxt[i]].pb(i);
    }

    vector<int> cost(3 * n), used(3 * n);
    unordered_map<int, int> cnt;
    auto dfs3 = [&](int v, auto&&self) -> void {
        used[v] = 1;
        for (auto &u : G[v]) {
            if (!used[u]) {
                int addd = 0;
                if (cnt[c[vt_num[u]]] == 0) addd = 1;
                cnt[c[vt_num[u]]]++;
                cost[u] = cost[v] + addd;
                self(u, self);
                cnt[c[vt_num[u]]]--;
            }
        }
    };
    for (int i = 0;i<n;i++)vt_num[i]=i;
    for (int i = 0; i < 3 * n; i++) {
        if (nxt[i] == -1 && vt_num[i] != -1) {
            cnt[c[vt_num[i]]]++;
            cost[i] = 1;
            dfs3(i, dfs3);
            cnt[c[vt_num[i]]]--;
        }
    }
    // for (int i = 0; i < n; i++) cout << nxt[i] << ' ';
    // cout << '\n';
    for (int i = 0; i < n; i++) cout << (final_vertex[i] == -1 ? 0 : cost[final_vertex[i]]) << '\n';
}

signed main() {
    int tt = 1;
    #ifdef LOCAL 
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
        cin >> tt;
    #else
        ios::sync_with_stdio(false); 
        cin.tie(0); cout.tie(0);
    #endif

    while (tt--) {
        solve();
    }

    return 0;
}