#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
const int MAXN = 100008;
vector<pair<int, ll>> edg[MAXN];
ll prof[MAXN];
ll ans[MAXN];
int k;
vector<ll> merge(vector<ll>& a, vector<ll>& b) {
int n = a.size();
int m = b.size();
vector<ll> ans(n + m - 1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
ans[i + j] = max(ans[i + j], a[i] + b[j]);
}
}
return ans;
}
vector<ll> dfs_(int v, int rt) {
if (edg[v].empty() || edg[v].size() == 1 && edg[v][0].first == rt) {
return {0, 0};
}
vector<vector<ll>> prof_edg;
for (auto [u, d] : edg[v]) {
if (u == rt)
continue;
prof_edg.push_back(dfs_(u, v));
for (auto& x : prof_edg.back()) {
x += d;
}
prof_edg.back()[0] -= d;
}
while (prof_edg.size() > 1) {
int n = prof_edg.size();
vector<vector<ll>> new_profedg;
for (int i = 0; i + 1 < n; i += 2) {
new_profedg.push_back(merge(prof_edg[i], prof_edg[i + 1]));
}
if (n % 2) {
new_profedg.push_back(prof_edg.back());
}
prof_edg = new_profedg;
}
return prof_edg.back();
}
struct stree {
void assign(vector<ll>& v) {
sz = v.size();
t.resize(sz * 2 - 1);
assign(0, 0, sz, v);
}
ll get_full() {
return t[0];
}
ll get_full_replace(int i, ll v) {
return get_full_replace(0, 0, sz, i, v);
}
private:
vector<ll> t;
int sz;
void assign(int ind, int lnd, int rnd, vector<ll>& v) {
if (rnd - lnd == 1) {
t[ind] = v[lnd];
return;
}
int mnd = (lnd + rnd) / 2;
assign(ind + 1, lnd, mnd, v);
assign(ind + (mnd - lnd) * 2, mnd, rnd, v);
t[ind] = max(t[ind + 1], t[ind + (mnd - lnd) * 2]);
}
ll get_full_replace(int ind, int lnd, int rnd, int i, ll& v) {
if (i < lnd || rnd <= i)
return t[ind];
if (rnd - lnd == 1) {
return v;
}
int mnd = (lnd + rnd) / 2;
return max(get_full_replace(ind + 1, lnd, mnd, i, v), get_full_replace(ind + (mnd - lnd) * 2, mnd, rnd, i, v));
}
};
void dfs(int v, int rt) {
if (edg[v].empty() || edg[v].size() == 1 && edg[v][0].first == rt) {
prof[v] = 0;
return;
}
vector<ll> prof_edg;
for (auto [u, d] : edg[v]) {
if (u == rt)
continue;
dfs(u, v);
prof_edg.push_back(prof[u]);
prof_edg.back() += d;
}
stree tr;
tr.assign(prof_edg);
prof[v] = tr.get_full();
return;
}
void dfs_ans(int v, int rt) {
ans[v] = prof[v];
//if (k >= prof[v].size()) {
//ans[v] = prof[v].back();
//} else {
//ans[v] = prof[v][k];
//}
vector<ll> prof_edg;
for (auto [u, d] : edg[v]) {
prof_edg.push_back(prof[u]);
prof_edg.back() += d;
}
stree tr;
tr.assign(prof_edg);
int n = edg[v].size();
for (int i = 0; i < n; ++i) {
auto [u, d] = edg[v][i];
if (u == rt)
continue;
prof[v] = tr.get_full_replace(i, 0);
prof[v] += d;
ll profu = prof[u];
prof[u] = max(prof[u], prof[v]);
prof[v] -= d;
dfs_ans(u, v);
prof[u] = profu;
}
prof[v] = tr.get_full();
}
signed main() {
int n;
cin >> n >> k;
for (int i = 0; i + 1 < n; ++i) {
int u, v, c;
cin >> u >> v >> c;
--u, --v;
edg[u].push_back({v, c});
edg[v].push_back({u, c});
}
if (k == 1) {
dfs(0, -1);
dfs_ans(0, -1);
for (int i = 0; i < n; ++i) {
cout << ans[i] << '\n';
}
} else {
for (int i = 0; i < n; ++i) {
vector<ll> ppf = dfs_(i, -1);
if (k >= ppf.size())
cout << ppf.back() << '\n';
else
cout << ppf[k] << '\n';
}
}
}
