#include <bits/stdc++.h>

using namespace std;

constexpr int MAX_N = 40001, MAX_K = 3001;

using ll = long long;

int N, K;
vector<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) {
    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].resize(Adj[v].size() - (p != 0) + 1);
    Dp[v][0].resize(1);

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

    int it = 1;
    sort(Adj[v].begin(), Adj[v].end(), [&] (int a, int b) {
        return Dp[a].back().size() < Dp[b].back().size();
    });
    for (auto &nxt: Adj[v]) {
        if (nxt == p) continue;

        auto nxt_dp = Dp[nxt].back();
        Extend(nxt_dp, nxt);
        Dp[v][it] = Dp[v][it - 1];
        Comb(Dp[v][it], nxt_dp);

        it++;
    }

}

void Dfs2(int v, vector<ll> cumult_dp={}, int p=0) {
    reverse(Adj[v].begin(), Adj[v].end());

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

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

        Dfs2(nxt, prev_cdp, v);

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

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

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);
    }

    Dfs1(1);
    Ans[1] = Dp[1].back()[K - 1] + A[1];
    Dfs2(1);

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