hdu 5029 Relief grain

        题意：n个地区组成树型结构，有若干次操作(x,y,z)，每次在x-y的路径上发放编号为z的粮食，问最后每个地区发放次数最多的是几号粮食。

        思路：树链剖分。这题我写了整整三天。。还学习了一些预备知识，还是自己太弱了。对树进行剖分以后，难点在线段树到底维护什么。很容易就想到线段树每个节点代表一段地区，其实这样是不对的，每个节点应该代表的是一段粮食类型（维护数量最多的类型和对应的数量）。对每个地区开一个链表，操作(x,y,z)，就在x里面加入z，y+1里面加入-z。然后按顺序对每个地区进行处理，处理完一个地区后，线段树根部的类型就是这个地区数量最多的类型。

#include<iostream>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<algorithm>
#include<string.h>
#include<cstdio>

using namespace std;

#define MAXN 100010

#define L(u) (u<<1)    
#define R(u) (u<<1|1)    

int n, m, q;    
int tim;       //时间戳    
int num[MAXN]; //树上每个节点的初始值    
int siz[MAXN]; //siz[u]表示以u为根的子树的节点数    
int top[MAXN]; //树链上深度最小的点    
int son[MAXN]; //重儿子    
int dep[MAXN]; //深度    
int tid[MAXN]; //节点的时间戳    
int _tid[MAXN]; //tid[i]=j表示时间戳为i的节点是j    
int father[MAXN]; //父节点    
bool vis[MAXN];    
vector<int> edge[MAXN];    

int ans[MAXN];
vector<int> R[MAXN];

void init(int n){
    for(int i = 1; i <= n; i++){
        siz[i] = top[i] = son[i] = 0;    
        dep[i] = tid[i] = _tid[i] = father[i] = 0;    
        vis[i] = false;    
        tim = 0; //时间戳    
        edge[i].clear();    
    }    
    memset(R,0,sizeof(R));
}    

inline void addedge(int u, int v){	//无根树加双向边
    edge[u].push_back(v);    
    edge[v].push_back(u);    
}    

//树链剖分    
void dfs1(int u, int pre){
    vis[u] = true;    
    siz[u] = 1;    
    father[u] = pre;    
    dep[u] = dep[pre] + 1; //注意根节点比较特殊    
    int sz = edge[u].size();    
    for(int i = 0; i < sz; i++){ 
        int v = edge[u][i];    
        if(v != father[u] && vis[v] == false){  
            dfs1(v, u);    
            siz[u] += siz[v];    
            if(son[u] == 0) son[u] = v;    
            else if(siz[son[u]] < siz[v]) son[u] = v;    
        }    
    }    
}    
    
void dfs2(int u, int tp){
    vis[u] = true;    
    tid[u] = ++tim;    
    _tid[tim] = u;    
    top[u] = tp;    
    if(son[u] != 0)    
        dfs2(son[u], tp); //同一条重链的顶部相同    
    
    int sz = edge[u].size();    
    for(int i = 0; i < sz; i++){ 
        int v = edge[u][i];    
        if(v != father[u] && v != son[u] && vis[v] == false) //注意去掉重儿子    
            dfs2(v, v);    
    }    
}

void change(int x, int y, int val)    {
    while(top[x] != top[y])    
    {    
        if(dep[top[x]] < dep[top[y]])    
            swap(x, y);    
		R[tid[top[x]]].push_back(val);
		R[tid[x]+1].push_back(-val);
        x = father[top[x]]; //因为top[x]->x路径上的所有点已经被更新了    
    }    
    
    if(dep[x] > dep[y]) //同一条重链上深度小的tid小    
        swap(x, y);      
    R[tid[x]].push_back(val);
	R[tid[y]+1].push_back(-val);
}    

//线段树部分    
struct node{
	int l,r;
	int MAX;
	int col;
};
node tree[MAXN<<2];

void build_tree(int n,int l,int r){
	tree[n].l=l; tree[n].r=r;
	tree[n].MAX=tree[n].col=0;
	if(l==r)return;
	int mid=(l+r)>>1;
	build_tree(L(n),l,mid);
	build_tree(R(n),mid+1,r);
}

void push_up(int x){
	node& lch=tree[L(x)];
	node& rch=tree[R(x)];
	
	if(rch.MAX>lch.MAX){
		tree[x].MAX=rch.MAX;
		tree[x].col=rch.col;
	}else{
		tree[x].MAX=lch.MAX;
		tree[x].col=lch.col;
	}
}

void update(int n,int c, int v){
	if(tree[n].l==tree[n].r){
		tree[n].MAX+=v;
		if(tree[n].MAX>0) tree[n].col=tree[n].l;
		else tree[n].col=0;
		return;
	}
	int mid=(tree[n].l+tree[n].r)>>1;
	if(c<=mid){
		update(L(n),c,v);
	}else{
		update(R(n),c,v);
	}
	push_up(n);
}

int main(){
	while(cin>>n>>m){
		if(n==0&&m==0)break;
		init(n);
		for(int i=1;i<n;i++){
			int u,v;
			scanf("%d%d",&u,&v);
			addedge(u,v);
		}
		
		memset(vis, 0, sizeof(vis));
		dfs1(1,0);
		memset(vis, 0, sizeof(vis));
		dfs2(1,1);
		
		for(int i=1;i<=m;i++){
			int u,v,z;
			scanf("%d%d%d",&u,&v,&z);
			change(u,v,z);
		}
		
		build_tree(1,1,100000);
		
		for(int i=1;i<=n;i++){
			int kk=R[i].size();
			for(int j=0;j<kk;j++){
				update(1,abs(R[i][j]), R[i][j]>0?1:-1 );
			}
			ans[_tid[i]]=tree[1].col;
		}
		for(int i=1;i<=n;i++){
			printf("%d\n",ans[i]);
		}
	}
	return 0;
}