#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) {
    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) {
    for (auto &nxt: Adj[v]) {
        if (nxt != p) Dfs1(nxt, v);
    }

    Dp[v].resize(Adj[v].size() - (p != 0) + 1);
    Dp[v][0].resize(2);

    int it = 1;
    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());

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

        Dp[v].pop_back();

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

        auto nxt_cdp = prev_cdp;

        auto nxt_dp = Dp[nxt].back();

        Comb(prev_cdp, nxt_dp);
        Extend(prev_cdp, nxt);
        Ans[nxt] = prev_cdp[K];
        
        Dfs2(nxt, nxt_cdp, v);
        
        Comb(cumult_dp, nxt_dp);
    }
}

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] << " ";
    }
}