HDU 5029 Relief grain --树链剖分第一题

题意：给一棵树，每次给两个节点间的所有节点发放第k种东西，问最后每个节点拿到的最多的东西是哪种。

解法：解决树的路径上的修改查询问题一般用到的是树链剖分+线段树，以前不会写，后来学了一下树链剖分，感觉也不是很难，就是把整个数分成很多链，然后一条重链上的点在线段树中位置是连续的，这样使得更新和查询时更加便利。

这个题目中线段树应该维护的是种类，每次对u-v发放k时，可以让u处+k，v+1处-k，把这些都离线存起来，然后枚举1~n，分别把自己该做的操作都做了，然后统计的时候tree[1].type就是该点的type。

这题是借鉴别人的代码写的，总算对树链剖分的题有所了解了。

还有在HDU交C++会爆栈，要加一个扩栈语句，不想加交G++也可以。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
#define N 100007

int siz[N];  //子树大小
int son[N];  //重儿子
int dep[N];  //深度
int pos[N];  //在线段树中的位置
int apos[N]; //线段树中位置对应的点
int Top[N];  //所在重链的祖先
int fa[N];   //父节点
int ans[N];  //答案
int head[*N],tot,POS,n,m;
struct Edge
{
    int v,next;
}G[*N];

struct Tree
{
    int num,type;
}tree[*N];

struct node
{
    int u,v,z;
    node(){}
    node(int _u,int _v,int _z):u(_u),v(_v),z(_z){}
};
vector<node> com;
vector<int> Q[N];

void init()
{
    POS = tot = ;
    memset(head,-,sizeof(head));
    memset(son,-,sizeof(son));
    com.clear();
    for(int i=;i<=n+;i++)
        Q[i].clear();
}

void addedge(int u,int v)
{
    G[tot].v = v, G[tot].next = head[u], head[u] = tot++;
    G[tot].v = u, G[tot].next = head[v], head[v] = tot++;
}

void pushup(int rt)
{
    if(tree[*rt].num >= tree[*rt+].num)
        tree[rt].type = tree[*rt].type;
    else
        tree[rt].type = tree[*rt+].type;
    tree[rt].num = max(tree[*rt].num,tree[*rt+].num);
}

void build(int l,int r,int rt)
{
    tree[rt].num = ;
    if(l == r)
    {
        tree[rt].type = l;
        return;
    }
    int mid = (l+r)/;
    build(l,mid,*rt);
    build(mid+,r,*rt+);
    pushup(rt);
}

void update(int l,int r,int pos,int val,int rt)
{
    if(l == r)
    {
        tree[rt].num += val;
        return;
    }
    int mid = (l+r)/;
    if(pos <= mid)
        update(l,mid,pos,val,*rt);
    else
        update(mid+,r,pos,val,*rt+);
    pushup(rt);
}

void dfs(int u,int f)
{
    dep[u] = dep[f]+;
    siz[u] = ;
    for(int i=head[u];i!=-;i=G[i].next)
    {
        int v = G[i].v;
        if(v == f) continue;
        fa[v] = u;
        dfs(v,u);
        if(son[u] == - || siz[v] > siz[son[u]]) son[u] = v;
        siz[u] += siz[v];
    }
}

void dfs2(int u,int father)
{
    pos[u] = ++POS;
    apos[POS] = u;
    Top[u] = father;
    if(son[u] != -) dfs2(son[u],father);   //有重儿子优先dfs
    for(int i=head[u];i!=-;i=G[i].next)
    {
        int v = G[i].v;
        if(v != fa[u] && v != son[u])
            dfs2(v,v);
    }
}

void getcom(int u,int v,int z)
{
    int fx = Top[u], fy = Top[v];
    while(fx != fy)
    {
        if(dep[fx] < dep[fy])
        {
            swap(u,v);
            swap(fx,fy);
        }
        com.push_back(node(pos[fx],pos[u],z));
        u = fa[fx];
        fx = Top[u];
    }
    if(dep[u] > dep[v]) swap(u,v);
    com.push_back(node(pos[u],pos[v],z));
}

int main()
{
    int i,j,maxi,u,v,z;
    while(scanf("%d%d",&n,&m)!=EOF && n+m)
    {
        init();
        for(i=;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            addedge(u,v);
        }
        dep[] = ;
        dfs(,);
        dfs2(,);
        maxi = ;
        while(m--)
        {
            scanf("%d%d%d",&u,&v,&z);
            getcom(u,v,z);
            maxi = max(maxi,z);
        }
        int SIZE = com.size();
        for(i=;i<SIZE;i++)
        {
            int u = com[i].u, v = com[i].v, z = com[i].z;
            Q[u].push_back(z);
            Q[v+].push_back(-z);
        }
        build(,maxi,);
        for(i=;i<=n;i++)
        {
            sort(Q[i].begin(),Q[i].end());
            int sz = Q[i].size();
            for( j=;j<sz;j++)
            {
                int p = Q[i][j];
                if(p < ) update(,maxi,-p,-,);
                else      update(,maxi,p,,);
            }
            ans[apos[i]] = tree[].type;
            if(tree[].num == ) ans[apos[i]] = ;
        }
        for(i=;i<=n;i++)
            printf("%d\n",ans[i]);
    }
    return ;
}