#include <bits/stdc++.h>

using namespace std;

constexpr int MAX_N = 40001, MAX_K = 3001;

using ll = long long;

int N, K;
vector<ll> Dp[MAX_N];
ll A[MAX_N], Ans[MAX_N];
vector<int> Adj[MAX_N];

void Comb(vector<ll> &dp1, vector<ll> &dp2) {
    assert(dp1.size() <= K + 1 && dp2.size() <= K + 1);

    dp1.resize(min(K, (int) dp1.size() + (int) dp2.size() - 1) + 1);

    for (int i = (int) dp1.size() - 1; i >= 0; i--) {
        for (int j = min(i, (int) dp2.size() - 1); j >= 0; j--) {
            dp1[i] = max(dp1[i], dp1[i - j] + dp2[j]);
        }
    }
}

void Extend(vector<ll> &dp, int v) {
    if (dp.size() <= K) dp.push_back(0);

    for (int i = (int) dp.size() - 2; i >= 0; i--) {
        dp[i + 1] = dp[i] + A[v];
    }
}

void Dfs1(int v, int p=0) {
    Dp[v].push_back(0);

    for (auto &nxt: Adj[v]) {
        if (nxt != p) {
            Dfs1(nxt, v);

            auto nxt_dp = Dp[nxt];
            Extend(nxt_dp, nxt);
            Comb(Dp[v], nxt_dp);
        }
    }
}

void Dfs2(int v, vector<ll> par_dp={0}, int p=0) {
    vector<vector<ll>> cdp(Adj[v].size() - (p != 0) + 1);
    cdp[0] = par_dp;
    int it = 1;
    for (auto &nxt: Adj[v]) {
        if (nxt == p) continue;
        
        cdp[it] = cdp[it - 1];
        auto nxt_dp = Dp[nxt];
        Extend(nxt_dp, nxt);
        Comb(cdp[it], nxt_dp);
        
        it++;
    }

    reverse(Adj[v].begin(), Adj[v].end());

    it = (int) cdp.size() - 1;
    vector<ll> cumult_dp = {0};

    for (auto &nxt: Adj[v]) {
        if (nxt == p) continue;
        it--;

        auto prev_cdp = cumult_dp;
        Comb(prev_cdp, cdp[it]);
        Extend(prev_cdp, v);

        Dfs2(nxt, prev_cdp, v);

        for (int i = 0; i < min((int) prev_cdp.size(), K); i++) {
            if (K - i - 1 < Dp[nxt].size()) {
                Ans[nxt] = max(Ans[nxt], prev_cdp[i] + Dp[nxt][K - i - 1]);
            }
        }
        Ans[nxt] += A[nxt];

        Extend(Dp[nxt], nxt);
        Comb(cumult_dp, Dp[nxt]);
    }
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(0);

    cin >> N >> K;
    for (int i = 1; i <= N; i++) cin >> A[i];
    for (int it = 0; it < N - 1; it++) {
        int u, v; cin >> u >> v;
        Adj[u].push_back(v);
        Adj[v].push_back(u);
    }

    int root = 1;
    Dfs1(root);
    Ans[root] = Dp[root][K - 1] + A[root];
    Dfs2(root);

    for (int i = 1; i <= N; i++) {
        cout << Ans[i] << " ";
    }
}