Description：

Solution：

Code：

#include<algorithm>

#include<iostream>

#include<cstdlib>

#include<cstdio>

#include<cmath>

#include<vector>

#include<cstring>

using namespace std;

inline int read()

{

	register int res = 0;

	register char c = getchar();

	while(!isdigit(c))c = getchar();

	while(isdigit(c))

	{

		res = (res << 1) + (res << 3) + c - '0';

		c = getchar();

	}

	return res;

}

int n,m;

#define MAXN 100010

struct edge

{

	int to,nxt;

}e[MAXN << 1];

int edgenum = 0;

int lin[MAXN] = {0};

void add(int a,int b)

{

	++edgenum;e[edgenum].to = b;e[edgenum].nxt = lin[a];lin[a] = edgenum;

	++edgenum;e[edgenum].to = a;e[edgenum].nxt = lin[b];lin[b] = edgenum;

	return;

}

int fa[MAXN],top[MAXN],son[MAXN],siz[MAXN],dep[MAXN];

void dfs1(int k,int depth)

{

	dep[k] = depth;siz[k] = 1;

	for(int i = lin[k];i != 0;i = e[i].nxt)

	{

		if(e[i].to != fa[k])

		{

			fa[e[i].to] = k;

			dfs1(e[i].to,depth + 1);

			siz[k] += siz[e[i].to];

			if(son[k] == 0 || siz[e[i].to] > siz[son[k]])

			{

				son[k] = e[i].to;

			}

		}

	}

	return;

}

void dfs2(int k,int tp)

{

	top[k] = tp;

	if(son[k] == 0)return;

	dfs2(son[k],tp);

	for(int i = lin[k];i != 0;i = e[i].nxt)

	{

		if(e[i].to != fa[k] && e[i].to != son[k])

		{

			dfs2(e[i].to,e[i].to);

		}

	}

	return;

}

inline int LCA(int a,int b)

{

	while(top[a] != top[b])

	{

		if(dep[top[a]] < dep[top[b]])swap(a,b);

		a = fa[top[a]];

	}

	return (dep[a] < dep[b] ? a : b);

}

#define fi first

#define se second

vector< pair<int,int> > v[MAXN];

struct node

{

	int lc,rc;

	int maxv,pos;

}t[MAXN * 60];

int ptr = 0;

int newnode(){return ++ptr;}

int root[MAXN];

#define mid ((l + r) >> 1)

void maintain(int rt)

{

	if(t[rt].lc == 0 && t[rt].rc == 0)

	{

		t[rt].maxv = t[rt].pos = 0;

		return;

	}

	if(t[rt].lc == 0)

	{

		t[rt].maxv = t[t[rt].rc].maxv;

		t[rt].pos = t[t[rt].rc].pos;

		return;

	}

	if(t[rt].rc == 0)

	{

		t[rt].maxv = t[t[rt].lc].maxv;

		t[rt].pos = t[t[rt].lc].pos;

		return;

	}

	if(t[t[rt].lc].maxv >= t[t[rt].rc].maxv)

	{

		t[rt].maxv = t[t[rt].lc].maxv;

		t[rt].pos = t[t[rt].lc].pos;

		return;

	}

	else

	{

		t[rt].maxv = t[t[rt].rc].maxv;

		t[rt].pos = t[t[rt].rc].pos;

		return;

	}

}

void insert(int &rt,int p,int k,int l,int r)

{

	if(rt == 0)rt = newnode();

	if(l == r)

	{

		t[rt].pos = l;

		t[rt].maxv += k;

		return;

	}

	if(p <= mid)insert(t[rt].lc,p,k,l,mid);

	else insert(t[rt].rc,p,k,mid + 1,r);

	maintain(rt);

	return;

}

int merge(int x,int y,int l,int r)

{

	if(!x)return y;if(!y)return x;

	if(l == r)

	{

		t[x].pos = l;

		t[x].maxv += t[y].maxv;

		return x;

	}

	t[x].lc = merge(t[x].lc,t[y].lc,l,mid);

	t[x].rc = merge(t[x].rc,t[y].rc,mid + 1,r);

	maintain(x);

	return x;

}

bool vis[MAXN];

int ans[MAXN];

void dfs(int k)

{

	vis[k] = true;

	for(int i = lin[k];i != 0;i = e[i].nxt)

	{

		if(vis[e[i].to])continue;

		dfs(e[i].to);

		root[k] = merge(root[k],root[e[i].to],1,100000);

	}

	for(vector< pair<int,int> >::iterator i = v[k].begin();i != v[k].end();++i)

		insert(root[k],i -> fi,i -> se,1,100000);

	ans[k] = t[root[k]].pos;

	return;

}

int main()

{

	scanf("%d%d",&n,&m);

	for(int i = 1;i < n;++i)add(read(),read());

	dfs1(1,1);dfs2(1,1);

	int a,b,c;

	for(int i = 1;i <= m;++i)

	{

		a = read();b = read();c = read();

		v[a].push_back(make_pair(c,1));

		v[b].push_back(make_pair(c,1));

		int lca = LCA(a,b);

		v[lca].push_back(make_pair(c,-1));

		v[fa[lca]].push_back(make_pair(c,-1));

	}

	memset(vis,false,sizeof(vis));

	dfs(1);

	for(int i = 1;i <= n;++i)

	{

		printf("%d\n",ans[i]);

	}

	return 0;

}