HDU - 5029:Relief grain(树链剖分+线段树+特殊维护)

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5029

题目大意：

有一些村庄相互连通，构成一颗树，每次会给两个村子间的所有村子送一种类型的粮食，问最后每个村庄被送的最多的粮食是哪一种。

解题思路：

首先是树，并且要对两个村庄之间进行操作，所以首先肯定要用树链剖分将问题转换成线性。那么线性上问题应该怎么解决呢。

这一点想了好久，甚至想到了离线，但是感觉复杂度还是太高。想了好几天，最后还是去看了大佬的博客，不禁感叹又学到了新的东西，这个方法是真的巧妙，

首先先确立一颗线段树，线段树最底层结点存每个颜色及其出现的次数，每个结点保存有两个值，一个是当前区间的出现次数最多的颜色，一个是当前区间的出现次数最多的颜色的出现的次数（语文学的不好真痛苦）。

线段树先放在这儿不管，讲一下实现这个题目要求的算法，

首先对于一次操作 l r w 即在 l 和 r 间村庄运送w类型的l粮食，那么我们用一个vector 假设为 vk ，vk[ i ]表示第 i 个村庄被运送的粮食种类，

那么需要 vk[ l ].push_back(w),vk[ r+1 ].push_back(-w)

难以表达，举个例子，线性的，

假设有村庄1~2，

我们进行如下操作，

1 2 3

1 1 4

2 2 3

那么我们vk[ 1 ]里面应该存有3 4 vk[ 2 ]里面应该存有3 -4 3

这样写有什么好处呢，这样写了以后，我们可以按照村庄的顺序依次更新线段树，对于vector里面的数 k ，若是k>0，将k种类的粮食出现次数+1 k<0就-1，

具体还是讲不清楚，看代码应该容易理解一点，

#include <bits/stdc++.h>
#define rank ra
#define lson rt<<1
#define rson rt<<1|1
#define pb push_back
using namespace std;
typedef long long LL;
const int N=100005;
int n,m,step,cnt;
int w[N],fa[N],size[N],dep[N],son[N],head[N],top[N],rank[N],ans[N];
vector<int> vk[N];
struct node
{
    int u,v,w;
    int next;
}edge[N<<1];
struct tree
{
    int l,r,mid;
    int dir,su;
}t[N<<2];
void add(int u,int v)
{
    edge[cnt].u=u;edge[cnt].v=v;
    edge[cnt].next=head[u];head[u]=cnt++;
    return ;
}
//树链剖分模板
void dfs1(int u,int far,int de)
{
    fa[u]=far;dep[u]=de;size[u]=1;son[u]=0;
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==far)
            continue;
        dfs1(v,u,de+1);
        size[u]+=size[v];
        if(size[son[u]]<size[v])
            son[u]=v;
    }
}
void dfs2(int u,int tp)
{
    top[u]=tp;
    w[u]=++step;
    rank[step]=u;
    if(son[u]>0)
        dfs2(son[u],tp);
    for(int i=head[u];i!=-1;i=edge[i].next)
    {
        int v=edge[i].v;
        if(v==fa[u]||v==son[u])
            continue;
        dfs2(v,v);
    }
    return ;
}
//基本的线段树维护操作
void pushup(int rt)
{
    t[rt].su=max(t[lson].su,t[rson].su);
    if(t[lson].su>=t[rson].su)
        t[rt].dir=t[lson].dir;
    else
        t[rt].dir=t[rson].dir;
}
void build(int l,int r,int rt)
{
    int m=(l+r)>>1;
    t[rt].l=l;t[rt].r=r;
    t[rt].mid=m;
    t[rt].su=0;
    if(l==r)
    {
        t[rt].dir=l;
        t[rt].su=0;
        return ;
    }
    build(l,m,lson);
    build(m+1,r,rson);
    pushup(rt);
}
void update(int pos,int k,int rt)
{
    if(t[rt].l==t[rt].r)
    {
        if(k>0)     //根据k的正负判断次数++和--
            t[rt].su++;
        else
            t[rt].su--;
        return ;
    }
    if(pos<=t[rt].mid)
        update(pos,k,lson);
    if(pos>t[rt].mid)
        update(pos,k,rson);
    pushup(rt);
}
//将树上的区间转换为线性的
void slove(int u,int v,int dir)
{
    while(top[u]!=top[v])
    {
        if(dep[top[u]]<dep[top[v]])
            swap(u,v);
        vk[w[top[u]]].pb(dir);
        vk[w[u]+1].pb(-dir);
        u=fa[top[u]];
    }
    if(dep[u]>dep[v])
        swap(u,v);
    vk[w[u]].pb(dir);
    vk[w[v]+1].pb(-dir);
    return ;
}
void init()
{
    for(int i=0;i<=N;i++)
        vk[i].clear();
    memset(head,-1,sizeof head);
    memset(ans,0,sizeof ans);
    cnt=0;step=0;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0&&m==0)
            break;
        init();
        int u,v,w;
        for(int i=1;i<n;i++)
        {
            scanf("%d%d",&u,&v);
            add(u,v);
            add(v,u);
        }
        dfs1(1,0,1);
        dfs2(1,1);
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            slove(u,v,w);
        }
        build(1,N,1);
        for(int i=1;i<=n;i++)
        {
            for(int j=0;j<(int)vk[i].size();j++)
                update(abs(vk[i][j]),vk[i][j],1);
            if(t[1].su>0)   //这里要注意 没有被送过输出0
                ans[rank[i]]=t[1].dir;
        }
        for(int i=1;i<=n;i++)
            printf("%d\n",ans[i]);
    }
}