#include<cstdio>
#include<type_traits>
#include<initializer_list>
/**
 * Author: qL
 * Version: 0x01
 * Note:
 * 	Flush::Fast_Input_Flush_Safer can't work well now.
*/
namespace Default_Source{
	namespace IO{
		namespace Flush{
			struct Input_Flush_Base{char getc(){return getchar();}};
			template<std::size_t BUFSIZE>
			class Fast_Input_Flush_Base:Input_Flush_Base{
			protected:
				char buf[BUFSIZE],*cur=buf;
			public:
				Fast_Input_Flush_Base(){std::fread(buf,1,BUFSIZE,stdin);}
				char getc(){return *cur++;}
			};
			template<std::size_t BUFSIZE>
			class Fast_Input_Flush_Safer:Fast_Input_Flush_Base<BUFSIZE>{
			protected:
				using Fast_Input_Flush_Base<BUFSIZE>::buf;
				using Fast_Input_Flush_Base<BUFSIZE>::cur;
				char *nil=buf;
				void reload(){nil=(cur=buf)+std::fread(buf,1,BUFSIZE,stdin);}
			public:
				Fast_Input_Flush_Safer(){reload();}
				char getc(){return (cur==nil&&(reload(),true)),*cur++;}
			};
			struct Output_Flush_Base{void putc(char ch){putchar(ch);}};
			template<std::size_t BUFSIZE>
			class Fast_Output_Flush_Base:Output_Flush_Base{
			protected:
				char buf[BUFSIZE],*cur=buf;
			public:
				~Fast_Output_Flush_Base(){std::fwrite(buf,1,cur-buf,stdout);}
				void putc(char ch){*cur++=ch;}
			};
		}
		template<typename _Input_Flush=Flush::Input_Flush_Base>
		class Fast_InStream{
		private:
			static_assert(std::is_base_of<Flush::Input_Flush_Base,_Input_Flush>::value);
			static _Input_Flush Input;
			int Ch;
			using List_Out=std::initializer_list<int>;
		public:
			template<typename _Tp>
			typename std::enable_if<std::is_integral<_Tp>::value,void>::type read(_Tp &x){
				x=0;Ch=Input.getc();
				for(;Ch<'0'||Ch>'9';Ch=Input.getc());
				for(;Ch>='0'&&Ch<='9';Ch=Input.getc()) x=x*10+(Ch&15);
				return;
			}
			void read(char *str){
				char *ptr=str;
				while((*str=Input.getc())==' '||*str=='\n');
				while((*++str=Input.getc())!=' '&&*str!='\n');
				*str='\0';
			}
			template<typename ...Args>
			void read(Args &&...args){void(List_Out{(read(args),0)...});}
		};
		template<typename _Input_Flush>
		_Input_Flush Fast_InStream<_Input_Flush>::Input;
		template<typename _Output_Flush=Flush::Output_Flush_Base>
		class Fast_OutStream{
		private:
			static_assert(std::is_base_of<Flush::Output_Flush_Base,_Output_Flush>::value);
			static _Output_Flush Output;
			using List_Out=std::initializer_list<int>;
		public:
			template<typename _Tp>
			typename std::enable_if<std::is_integral<_Tp>::value,void>::type write(_Tp x){
				static char sta[114];
				int top=0;
				do sta[top++]=(x%10)|48,x/=10;
				while(x);
				while(top) Output.putc(sta[--top]);
			}
			void write(char Ch){Output.putc(Ch);}
			template<typename ...Args>
			void write(Args &&...args){void(List_Out{(write(args),0)...});}
			template<typename ...Args>
			void writeln(Args &&...args){write(args...),Output.putc('\n');}
		};
		template<typename _Output_Flush>
		_Output_Flush Fast_OutStream<_Output_Flush>::Output;
	}
}
using namespace Default_Source;
/**
 * 考虑先写个暴力版本。
 * 我们定义 f[u][k] 表示 u 的子树中匹配 k 对，u 随意匹配的答案。
 * 然后定义 g[u][k] 表示 u 的子树中匹配 k 对，u 不能匹配的答案。
 * 转移不是很好说，我们抽象为卷积：f[i]=max(i=j+k){g[j]+h[k]}
 * 那么 g[u] 就是直接把儿子的 f 卷起来，f[u]……好像也是卷起来？
 * u 跟儿子匹配怎么考虑？枚举一下这个儿子？
 * 不是很合理，不妨先卷一个 h 出来，然后 f[u][i]=max{h[i-1]+edge[u][v]}。
 * 是这样的。
 * 那么由于这是个树上匹配，所以是二分图，然后能费用流，于是……
 * 闵可夫斯基和是吧，直接做 O(n^2)。
 * 之后的优化貌似是 tricked，先写一写。
 * 天真了天真了，暴力没那么好写。
 * 其他部分用 f 卷，其中某个儿子用 g 卷得到最优，于是我们可以使用在 CF1442D Sum 得到的分治 trick 处理儿子！
 * HD！/bx/bx/bx（伏笔，来袭！）
 * 现在需要重链剖分优化，个人认为这是个很神奇的方案。
 * 我们对于轻儿子，可以直接分治跑出来，过得去。
 * 然后并进一条重链，考虑怎么弄。
 * 事实上一条重链相当于是一个序列，序列的每个位置下面挂了些什么怪力乱神。
 * 哦我懂了。
 * 然而我们的合并很恐怖，需要分成四大类进行讨论。
 * 我谔谔。
 * 等下哈，好像他们的做法和我的不是很一样。
 * 问题不大，自信即颠峰。
 * 等下上面那个轻儿子分治是 n^2 的……
 * 呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃呃
 * 重写吧垃圾 lq
*/
#include<string>
using ll=long long;
constexpr ll llInf=0x3f3f3f3f3f3f3f3f;
template<typename T>
const T &max(const T &lhs,const T &rhs){return lhs<rhs?rhs:lhs;}
using Poly=std::basic_string<ll>;
Poly times(const Poly &g,const Poly &h){
	if(h.empty()) return g;
	else if(g.empty()) return h;
	Poly f;f.resize(g.size()+h.size()-1),f[0]=g[0]+h[0];
	for(unsigned k=1,i=1,j=1;k!=f.size();++k)
		if(i==g.size()) f[k]=f[k-1]+h[j]-h[j-1],++j;
		else if(j==h.size()) f[k]=f[k-1]+g[i]-g[i-1],++i;
		else if(g[i]-g[i-1]>h[j]-h[j-1]) f[k]=f[k-1]+g[i]-g[i-1],++i;
		else f[k]=f[k-1]+h[j]-h[j-1],++j;
	return f;
}
Poly plus(const Poly &g,const int &v){
	Poly f;f.resize(g.size()+1),f[0]=g[0],f.back()=g.back()+v;
	for(unsigned k=1;k!=g.size();++k) f[k]=max(g[k],g[k-1]+v);
	return f;
}
Poly merge(const Poly &g,const Poly &h){
	Poly f;f.resize(max(g.size(),h.size()));
	for(unsigned k=0;k!=f.size();++k)
		f[k]=max(k<g.size()?g[k]:-llInf,k<h.size()?h[k]:-llInf);
	return f;
}
template<typename ...Args>
Poly merge(const Poly &f,const Args &...args){return merge(f,merge(args...));}
constexpr int N=2e5;
struct Val{Poly f,g;};
Val dot(const Val &g,const Val &h){
	Val f={};
	f.f=merge(times(g.f,h.g),times(g.g,h.f),f.g=times(g.g,h.g));
	return f;
}
Val p[N+1];
int n;
struct edge{int ver,cost;};
std::basic_string<edge> G[N+1];
int siz[N+1],dep[N+1],fa[N+1],son[N+1],top[N+1],val[N+1];
void dfs(int u){
	siz[u]=1,dep[u]=dep[fa[u]]+1;
	for(edge e:G[u]) if(e.ver!=fa[u])
		fa[e.ver]=u,dfs(e.ver),siz[u]+=siz[e.ver],
		val[e.ver]=e.cost,siz[son[u]]<siz[e.ver]&&(son[u]=e.ver);
}
int seq[N+1];
Val Light_Divide(int l,int r){
	if(l==r) return {plus(p[seq[l]].g,val[seq[l]]),p[seq[r]].f};
	int mid=(l+r)>>1;
	return dot(Light_Divide(l,mid),Light_Divide(mid+1,r));
}
struct Node{Poly q[2][2];};
/**
 * 理清思路：
 * 0 表示任意，1 表示不能。
 * 准则是：
 * 	- 任意的转移不成限制。
 * 	- 正常情况使用 times 卷。
 * 	- 不能劣于任意，一般不考虑。
 * 	- 考虑不能，则要求两边能凑出，此时用 plus 卷。
 * 	- 对于 plus 卷，0/1 限制了的不需要再用两边的限制。
*/
Node dot(const Node &g,const Node &h,int val,bool lhs,bool rhs){
	Node f={};
	f.q[1][1]=times(g.q[1][0],h.q[0][1]);
	if(lhs&&rhs) f.q[1][1]=merge(f.q[1][1],plus(times(g.q[1][1],h.q[1][1]),val));
	f.q[0][1]=merge(times(g.q[0][0],h.q[0][1]),f.q[1][1]),f.q[1][0]=merge(times(g.q[1][0],h.q[0][0]),f.q[1][1]);
	if(lhs) f.q[0][1]=merge(f.q[0][1],plus(times(g.q[0][1],h.q[1][1]),val));
	if(rhs) f.q[1][0]=merge(f.q[1][0],plus(times(g.q[1][1],h.q[1][0]),val));
	f.q[0][0]=merge(times(g.q[0][0],h.q[0][0]),plus(times(g.q[0][1],h.q[1][0]),val),f.q[0][1],f.q[1][0]);
	return f;
}
Node Heavy_Divide(int l,int r){
	if(l==r) return {p[seq[l]].f,p[seq[l]].g,p[seq[r]].g,p[seq[r]].g};
	int mid=(l+r)>>1;
	return dot(Heavy_Divide(l,mid),Heavy_Divide(mid+1,r),val[seq[mid+1]],l!=mid,mid+1!=r);
}
void dfs(int u,int tp){
	p[u]={{0},{0}};
	top[u]=tp,son[u]&&(dfs(son[u],tp),true);
	for(edge e:G[u]) if(!top[e.ver]) dfs(e.ver,e.ver);
	int tot=0;
	for(edge e:G[u]) if(e.ver!=fa[u]&&e.ver!=son[u]) seq[++tot]=e.ver;
	if(tot) p[u]=Light_Divide(1,tot);
	if(u!=tp) return;
	tot=0;
	for(int t=u;t;t=son[t]) seq[++tot]=t;
	auto tmp=Heavy_Divide(1,tot);
	p[u]={tmp.q[0][0],tmp.q[1][0]};
}
signed main(){
	std::scanf("%d",&n);
	for(int i=2,u,v,w;i<=n;++i) std::scanf("%d%d%d",&u,&v,&w),G[u]+={v,w},G[v]+={u,w};
	dfs(1),dfs(1,1);
	for(unsigned k=1;k!=p[1].f.size();++k) std::printf("%lld ",p[1].f[k]);
	for(n-=p[1].f.size();n;--n) std::printf("? ");
	return 0;
}