#include <bits/stdc++.h>
#define int long long
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define F(i, x, y) for (int i = (x); i <= (y); i++)
#define R(i, x, y) for (int i = (x); i >= (y); i--)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)

using namespace std;
typedef long long ll;
typedef pair<int, ll> pi;
typedef vector<ll> ve;
bool Mbe;

const ll inf = 1e18;

struct Mink {
	
	ve f;
	
	Mink () { f.clear(); }
	Mink (int n) { f.resize(n, 0); }
	Mink (int n, ll w) { f.resize(n, w); }
	Mink (ve w) { f = w; }
	
	ll & operator [] (const int &r) {
		return f[r];
	}
	
	int size() {
		return (int)f.size();
	}
	
	void emplace_back(ll w) {
		f.eb(w);
	}
	
	ve::iterator begin() {
		return f.begin();
	}
	
	ve::iterator end() {
		return f.end();
	}
	
	friend Mink operator + (Mink l, Mink r) {
		int sl = l.size(), sr = r.size();
		Mink cl(sl - 1), cr(sr - 1), res(sl + sr - 1), cres(sl + sr - 2);
		res[0] = l[0] + r[0];
		F (i, 0, sl - 2) {
			cl[i] = l[i + 1] - l[i];
		}
		F (i, 0, sr - 2) {
			cr[i] = r[i + 1] - r[i];
		}
		merge(cl.begin(), cl.end(), cr.begin(), cr.end(), cres.begin(), greater<int> ());
		F (i, 0, sl + sr - 3) {
			res[i + 1] = res[i] + cres[i];
		}
		return res;
	}
	
	friend Mink operator + (Mink l, ll r) {
		Mink res = l;
		res.eb(-inf);
		F (i, 1, l.size()) {
			res[i] = max(res[i], l[i - 1] + r);
		}
		return res;
	}
	
	friend Mink max(Mink l, Mink r) {
		int s = max(l.size(), r.size());
		Mink res(s, -inf);
		F (i, 0, s - 1) {
			if (i < l.size()) {
				res[i] = max(res[i], l[i]);
			}
			if (i < r.size()) {
				res[i] = max(res[i], r[i]);
			}
		}
		return res;
	}
	
};

struct Info1 {
	
	Mink f[2];
	
	Info1 () { }
	Info1 (Mink a, Mink b) { f[0] = a, f[1] = b; }
	
	Mink & operator [] (const int &r) {
		return f[r];
	}
	
	Info1 operator + (const ll &r) const {
		return Info1(max(f[0], f[1]), f[0] + r);
	}
	
};

struct Info2 {
	
	ll wr;
	Mink f[2][2];
	
	Info2 () { }
	Info2 (Info1 a, ll b) { f[0][1] = f[1][0] = Mink(1, -inf), f[0][0] = a[0], f[1][1] = a[1], wr = b; }
	
	Mink* operator [] (const int &r) {
		return f[r];
	}
	
};

const int N = 2e5 + 5;

int n;
int fa[N], sz[N], son[N], wson[N];

Info1 f[N];

vector<pi> G[N];

Info1 conq(vector<Info1>::iterator l, vector<Info1>::iterator r) {
	if (l == r - 1) {
		return *l;
	}
	auto mid = l + (r - l) / 2;
	Info1 L = conq(l, mid), R = conq(mid, r);
	return Info1(L[0] + R[0], max(L[1] + R[0], L[0] + R[1]));
}

Info2 conq(vector<Info2>::iterator l, vector<Info2>::iterator r) {
	if (l == r - 1) {
		return *l;
	}
	auto mid = l + (r - l) / 2;
	Info2 L = conq(l, mid), R = conq(mid, r), res;
	if (l == r - 2) {
		F (i, 0, 1) {
			F (j, 0, 1) {
				res[i][j] = L[i][i] + R[j][j];
			}
		}
		res[1][1] = max(res[1][1], (L[0][0] + R[0][0]) + L.wr);
	} else if (l == r - 3) {
		F (i, 0, 1) {
			F (j, 0, 1) {
				res[i][j] = max(L[i][0], L[i][1]) + R[j][j];
			}
		}
		res[0][1] = max(res[0][1], (L[0][0] + R[0][0]) + L.wr);
		res[1][1] = max(res[1][1], (L[1][0] + R[0][0]) + L.wr);
	} else {
		F (i, 0, 1) {
			F (j, 0, 1) {
				Mink a = (L[i][0] + R[0][j]) + L.wr;
				Mink b = max(L[i][0], L[i][1]) + max(R[0][j], R[1][j]);
				res[i][j] = max(a, b);
			}
		}
	}
	res.wr = R.wr;
	return res;
}

void dfs1(int u, int fat) {
	sz[u] = 1, fa[u] = fat;
	for (pi p : G[u]) {
		int v = p.fi;
		if (v == fat) {
			continue;
		}
		dfs1(v, u);
		sz[u] += sz[v];
		if (sz[son[u]] < sz[v]) {
			son[u] = v;
		}
	}
	for (pi p : G[u]) {
		int v = p.fi, w = p.se;
		if (v == son[u]) {
			wson[u] = w;
		}
	}
}

void dfs2(int u, int pr) {
	f[u][0] = f[u][1] = Mink(1, 0);
	if (!son[u]) {
		return;
	}
	dfs2(son[u], pr);
	for (pi p : G[u]) {
		int v = p.fi;
		if (v != fa[u] && v != son[u]) {
			dfs2(v, v);
		}
	}
	vector<Info1> F;
	for (pi p : G[u]) {
		int v = p.fi, w = p.se;
		if (v != fa[u] && v != son[u]) {
			F.eb(f[v] + w);
		}
	}
	if (!F.empty()) {
		f[u] = conq(F.begin(), F.end());
	}
	if (u == pr) {
		vector<Info2> G;
		int cur = u;
		while (cur) {
			G.eb(Info2(f[cur], wson[cur]));
			cur = son[cur];
		}
		Info2 res = conq(G.begin(), G.end());
		f[u][0] = max(res[0][0], res[0][1]);
		f[u][1] = max(res[1][0], res[1][1]);
	}
}

void solve() {
	cin >> n;
	F (i, 1, n - 1) {
		int u, v, w;
		cin >> u >> v >> w;
		G[u].eb(v, w), G[v].eb(u, w);
	}
	dfs1(1, 0);
	dfs2(1, 1);
	Mink res = max(f[1][0], f[1][1]);
	F (i, 1, n - 1) {
		if (i < res.size()) {
			cout << res[i] << ' ';
		} else {
			cout << "? ";
		}
	}
}

bool Med;
signed main() {
	// FIO("");
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	cerr << (&Mbe - &Med) / 1048576.0 << " MB\n";
	int T = 1;
	// cin >> T;
	while (T--) solve();
	cerr << (int)(1e3 * clock() / CLOCKS_PER_SEC) << " ms\n";
	return 0;
}