hdu5029 树链剖分

这题绝对好题。

题意很简单，也很容易想到树链剖分，之后就不太好做了。

开始想的是按颜色排序，然后每次处理一种颜色，求出最优解。这样做的话，最坏情况会退化到n^2，不可接受。

之后用线段树维护，一个节点只存在一种颜色，而且排序之后能保证在树中颜色不会交叉，pushdown的时候可以将两种都不是当前正在处理的颜色给覆盖掉，不过这样写有个bug一直没解决掉，就是如果更新一直在叶子节点，如何确定该不该覆盖存在问题，这种写法又挂掉了。

之后这种写法，完全利用了树链剖分的性质。树链剖分之后，一条链上的点在线段树中肯定是连续的，那么按照线段树中出现的先后位置连起来看，必然是一条条链首尾相接组成的，这样就可以将这颗树完全当做链来处理，在每次处理的起点+z，终点之后的位置-z，+z表示在这个节点z这种颜色要覆盖，-z表示z这种颜色覆盖结束，用线段树维护在当前位置每种颜色的数量，根节点的值便是需要的结果。注意线段树跟新链的区别，线段树维护的是新链的性质，而不是新链。

这题做完之后，剖分之后的树在脑中再也不是树，是链。

具体看代码：

#pragma comment(linker,"/STACK:102400000,102400000")
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <vector>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define delf int m=(l+r)>>1

using namespace std;

const int MAX=100010;
int top[MAX];
int num[MAX];
int son[MAX];
int fa[MAX];
int dep[MAX];
int pos[MAX];       //原树->新链
int cpos[MAX];      //新链->原树
int cn[MAX<<2];     //每个节点当前种子类型的种子数
int cz[MAX<<2];     //每个节点当前种子类型
int ans[MAX];       //答案
int head[MAX];
vector <int> mv[MAX];   //每个节点的标记
int n,m,curz,cnt,sss;

struct EDGE
{
    int to;
    int next;
} edge[MAX<<1];

struct PATH
{
    int x;      //起点
    int y;      //终点
    int z;      //类型
} path[MAX];

void init()     //初始化
{
    for (int i=1;i<=n;i++)
    {
        top[i]=num[i]=son[i]=fa[i]=dep[i]=head[i]=pos[i]=cpos[i]=-1;
        cn[i]=cz[i]=ans[i]=0;
        mv[i].clear();
    }
    cnt=0;
    sss=1;
    return ;
}

void add_edge(int a,int b,int i)        //建树
{
    edge[i].to=b;
    edge[i].next=head[a];
    head[a]=i;
    return ;
}

void dfs1(int u,int d,int f)
{
    dep[u]=d;
    fa[u]=f;
    num[u]=1;
    int next=head[u];
    while (next!=-1)
    {
        int to=edge[next].to;
        if (to!=f)
        {
            dfs1(to,d+1,u);
            if (son[u]==-1||num[to]>num[son[u]])
                son[u]=to;
            num[u]+=num[to];
        }
        next=edge[next].next;
    }
    return ;
}

void dfs2(int u,int t)
{
    top[u]=t;
    pos[u]=(++cnt);
    cpos[cnt]=u;
    if (son[u]!=-1)
        dfs2(son[u],t);
    int next=head[u];
    while (next!=-1)
    {
        int to=edge[next].to;
        if (to!=fa[u]&&to!=son[u])
            dfs2(to,to);
        next=edge[next].next;
    }
    return ;
}
//剖分结束
//线段树维护的是每种颜色的数量，cz代表颜色，cn代表数量
void swap(int &a,int &b)
{
    int t=a;
    a=b;
    b=t;
    return ;
}

void pushup(int rt)
{
    if (cn[rt<<1]>=cn[rt<<1|1])
    {
        cz[rt]=cz[rt<<1];
        cn[rt]=cn[rt<<1];
    }
    else
    {
        cz[rt]=cz[rt<<1|1];
        cn[rt]=cn[rt<<1|1];
    }
    return ;
}

void build(int l,int r,int rt)
{
    cn[rt]=cz[rt]=0;
    if (l==r)
        return ;
    delf;
    build (lson);
    build (rson);
    return ;
}

void update(int k,int v,int l,int r,int rt)
{
    if (l==r)
    {
        cn[rt]+=v;
        if (cn[rt]!=0)
            cz[rt]=k;
        else
            cz[rt]=0;
        return ;
    }
    delf;
    if (k<=m)
        update(k,v,lson);
    else
        update(k,v,rson);
    pushup(rt);
    return ;
}
//线段树结束

//标记首尾节点部分
void solve(int x,int y,int z)
{
    while (top[x]!=top[y])
    {
        if (dep[top[x]]<dep[top[y]])
            swap(x,y);
        mv[pos[x]+1].push_back(-z);     //这个节点在新链中的位置，由于链头在新链中的哈希值小于链尾，所以链头+z，链尾后一个-z
        mv[pos[top[x]]].push_back(z);
        x=fa[top[x]];
    }
    if (dep[x]<dep[y])
        swap(x,y);
    mv[pos[x]+1].push_back(-z);
    mv[pos[y]].push_back(z);
    return ;
}
//这样处理，所有覆盖到的链都进行了首+尾-的操作，那么直接从头开始扫描就行了，树链剖分的性质保证了在线段树中连续的点
//要么是两条链的尾部和首部，要么是一条链，可以自己画一下感觉一下
//标记结束

//从头先后扫描部分
void run()
{
    for (int i=1;i<=n;i++)      //相当于一条链，从头开始向后扫描，用线段树维护最大值
    {
        int s=mv[i].size();
        for (int t=0;t<s;t++)
        {
            int p=mv[i][t];
            if (p>0)
                update(p,1,1,sss,1);
            else
                update(-p,-1,1,sss,1);
        }
        ans[cpos[i]]=cz[1];     //当前点维护结束之后，根节点的就是答案
    }
    return ;
}

int main()
{
    while (scanf("%d%d",&n,&m)&&n+m)
    {
        init();
        for (int i=1;i<n;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            add_edge(a,b,i*2-1);
            add_edge(b,a,i*2);
        }
        dfs1(1,0,0);
        dfs2(1,1);
        for (int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&path[i].x,&path[i].y,&path[i].z);
            if (sss<path[i].z)
                sss=path[i].z;
        }
        for (int i=1;i<=m;i++)
            solve(path[i].x,path[i].y,path[i].z);
        build(1,sss,1);
        run();
        for (int i=1;i<=n;i++)
            printf("%d\n",ans[i]);
    }
}