#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][l] 表示 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（伏笔，来袭！）
*/
#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;
}
constexpr int N=2e5;
int n;
struct edge{int ver,cost;};
std::basic_string<edge> G[N+1];
Poly f[N+1],g[N+1];
int siz[N+1],dep[N+1],fa[N+1],son[N+1],top[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],
	// 	siz[son[u]]<siz[e.ver]&&(son[u]=e.ver);
}
edge seq[N+1];
void divide(int l,int r,const Poly &G,Poly &F){
	if(l==r)
		return F=merge(F,plus(times(G,g[seq[l].ver]),seq[l].cost)),void();
	int mid=(l+r)>>1;
	Poly H=G;
	for(int i=l;i<=mid;++i) H=times(H,f[seq[i].ver]);
	divide(mid+1,r,H,F);
	H=G;
	for(int i=mid+1;i<=r;++i) H=times(H,f[seq[i].ver]);
	divide(l,mid,H,F);
}
void dfs(int u,int fa){
	g[u]={0};
	for(edge e:G[u]) if(e.ver!=fa)
		dfs(e.ver,u),g[u]=times(g[u],f[e.ver]);
	f[u]=g[u];
	int top=0;
	for(edge e:G[u]) if(e.ver!=fa) seq[++top]=e;
	if(top) divide(1,top,Poly{0},f[u]);
}
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<n;++k)
		if(k<f[1].size()) std::printf("%lld ",f[1][k]);
		else std::printf("? ");
	return 0;
}