$RT$，不知道哪里错了，求$dalao$帮忙看看

// Author: Ame__
#include<bits/stdc++.h>
#include<stdint.h>
#define _ 0
#define AME__DEBUG
#define bomb exit(0)
#define LOG(FMT...) fprintf(stderr , FMT)
#define TOWA(FMT...) fprintf(stdout , FMT)
using namespace std;
/*Grievous Lady*/
    
typedef int32_t i32;
typedef int64_t i64;
typedef double qwq;
    
const int BUF_SIZE = 1 << 12;
char buf[BUF_SIZE] , *buf_s = buf , *buf_t = buf + 1;
    
#define PTR_NEXT() \
{ \
    buf_s ++; \
    if(buf_s == buf_t) \
    { \
        buf_s = buf; \
        buf_t = buf + fread(buf , 1 , BUF_SIZE , stdin); \
    } \
}
    
#define mians(_s_) \
{ \
    while(!isgraph(*buf_s)) PTR_NEXT();\
    char register *_ptr_ = (_s_); \
    while(isgraph(*buf_s) || *buf_s == '-') \
    { \
        *(_ptr_ ++) = *buf_s; \
        PTR_NEXT(); \
    } \
    (*_ptr_) = '\0'; \
}
    
const i32 kato = 3e6 + 10;
const i32 atri = 1e5;
const i32 INF = 0x3f3f3f3f;

template <typename _n_> void mian(_n_ & _x_){
    while(*buf_s != '-' && !isdigit(*buf_s)) PTR_NEXT();
    bool register _nega_ = false; if(*buf_s == '-'){ _nega_ = true; PTR_NEXT(); }
    _x_ = 0; while(isdigit(*buf_s)){ _x_ = _x_ * 10 + *buf_s - '0'; PTR_NEXT(); } if(_nega_) _x_ = -_x_;
}
    
template <typename _n_> bool cmax(_n_ &a , const _n_ &b){ return a < b ? a = b , 1 : 0; }
template <typename _n_> bool cmin(_n_ &a , const _n_ &b){ return a > b ? a = b , 1 : 0; }
    
i32 n , m , x , y , z;
i32 ans[kato];

namespace towa{
    struct Edge{
        i32 to;
        Edge *nxt;
    };

    struct Graph{
        Edge yuni[kato << 1] , *head[kato] , *tail;

        void clear(){ memset(head , 0x0 , sizeof head); tail = yuni; }

        Graph(){ clear(); }

        Edge *operator[](i32 x){ return head[x]; }

        void add(i32 x , i32 y){ *tail = (Edge){y , head[x]}; head[x] = tail ++; }
    }Ire;

    i32 cnt , dfn[kato] , dep[kato] , size[kato] , son[kato] , top[kato] , fa[kato] , id[kato];

    void dfs1(i32 u , i32 f){
        fa[u] = f; dep[u] = dep[f] + 1;
        size[u] = 1;
        for(Edge *i = Ire[u] ; i ; i = i -> nxt){
            i32 v = i -> to;
            if(v == f) continue;
            dfs1(v , u);
            size[u] += size[v];
            if(!son[u] || size[v] > size[son[u]]) son[u] = v;
        }
    }

    void dfs2(i32 u , i32 f){
        top[u] = f; dfn[u] = ++ cnt;
        id[cnt] = u;
        if(son[u]) dfs2(son[u] , f);
        for(Edge *i = Ire[u] ; i ; i = i -> nxt){
            i32 v = i -> to;
            if(!dfn[v]) dfs2(v , v);
        }
    }

    inline i32 LCA(i32 x , i32 y){
        while(top[x] != top[y]){
            if(dep[top[x]] < dep[top[y]]) swap(x , y);
            x = fa[top[x]];
        }
        if(dep[x] < dep[y]) swap(x , y);
        return y;
    }

    struct node{
        node *ls , *rs;
        static queue<node*> q;
        i32 val;
        node(i32 val = 0): val(val){
            ls = rs = 0x0;
        }
        inline void up(){
            this -> val = max(this -> val , max(this -> ls ? this -> ls -> val : 0 , this -> rs ? this -> rs -> val : 0));
        }
        void *operator new(size_t){
            static node *S = 0x0 , *T = 0x0; node *tmp;
            return q.empty() ? (S == T && (T = (S = new node[1024]) + 1024 , S == T) ? 0x0 : S ++) : (tmp = q.front() , q.pop() , tmp);
        }
    }*root[kato];

    queue<node*> node::q;

    inline void build(node *&o , i32 l , i32 r , i32 x , i32 v){
        if(!o) o = new node();
        if(l == r) return void(o -> val += v);
        i32 mid = (l + r) >> 1;
        if(x <= mid) build(o -> ls , l , mid , x , v);
        else build(o -> rs , mid + 1 , r , x , v);
        o -> up();
    }

    inline void merge(node *&x , node *&y , i32 l , i32 r){
        if(!y) return; if(!x) return void(x = y);
        if(l == r) return void(x -> val += y -> val);
        i32 mid = (l + r) >> 1;
        merge(x -> ls , y -> ls , l , mid);
        merge(x -> rs , y -> rs , mid + 1 , r);
        x -> up();
    }

    inline i32 get_ans(node *o , i32 l , i32 r){
        if(l == r) return l;
        i32 mid = (l + r) >> 1;
        i32 res1 = o -> ls ? o -> ls -> val : -INF;
        i32 res2 = o -> rs ? o -> rs -> val : -INF;
        return res1 >= res2 ? get_ans(o -> ls , l , mid) : get_ans(o -> rs , mid + 1 , r);
    }

    void dfs(i32 u , i32 f){
        for(Edge *i = Ire[u] ; i ; i = i -> nxt){
            i32 v = i -> to;
            if(v == f) continue;
            dfs(v , u);
            merge(root[u] , root[v] , 1 , atri);
        }
        if(root[u] && root[u] -> val) ans[u] = get_ans(root[u] , 1 , atri);
    }

    inline void Modify(i32 x , i32 y , i32 z){
        i32 lca = LCA(x , y);
        build(root[x] , 1 , atri , z , 1);
        build(root[y] , 1 , atri , z , 1);
        build(root[lca] , 1 , atri , z , -1);
        if(fa[lca]) build(root[fa[lca]] , 1 , atri , z , -1);
    }
}

inline int Ame_(){
#ifdef AME__
    freopen(".in" , "r" , stdin); freopen(".out" , "w" , stdout); int nol_cl = clock();
#endif
    mian(n) , mian(m);
    for(i32 i = 1;i < n;i ++){
        mian(x) , mian(y);
        towa::Ire.add(x , y); towa::Ire.add(y , x);
    }
    towa::dfs1(1 , 0); towa::dfs2(1 , 1);
    for(; m --> 0 ;){
        mian(x) , mian(y) , mian(z);
        towa::Modify(x , y , z);
    }
    towa::dfs(1 , 0);
    for(i32 i = 1;i <= n;i ++) TOWA("%d\n" , ans[i]);
#ifdef AME__TIME
    LOG("Time: %dms\n", int((clock() - nol_cl) / (qwq)CLOCKS_PER_SEC * 1000));
#endif
    return ~~(0^_^0); /*さようならプログラム*/
}
    
int Ame__ = Ame_();

int main(){;}