雨天的尾巴

Description

深绘里一直很讨厌雨天。

灼热的天气穿透了前半个夏天，后来一场大雨和随之而来的洪水，浇灭了一切。

虽然深绘里家乡的小村落对洪水有着顽固的抵抗力，但也倒了几座老房子，几棵老树被连

根拔起，以及田地里的粮食被弄得一片狼藉。

无奈的深绘里和村民们只好等待救济粮来维生。

不过救济粮的发放方式很特别。

首先村落里的一共有n 座房屋，并形成一个树状结构。然后救济粮分m 次发放，每次选择

两个房屋(x,y)，然后对于x 到y 的路径上（含x 和y) 每座房子里发放一袋z 类型的救济粮。

然后深绘里想知道，当所有的救济粮发放完毕后，每座房子里存放的最多的是哪种救济粮。

Input

第一行两个正整数n,m，含义如题目所示。

接下来n-1 行，每行两个数(a,b)，表示(a,b) 间有一条边。

再接下来m 行，每行三个数(x,y,z)，含义如题目所示。

Output

n 行，第i 行一个整数，表示第i 座房屋里存放的最多的是哪种救济粮，如果有多种救济粮

存放次数一样，输出编号最小的。

如果某座房屋里没有救济粮，则对应一行输出0。

Sample Input

5 3
1 2
3 1
3 4
5 4
2 3 3
1 5 2
3 3 3

Sample Output

2
3
3
2
2

Data Constraint

对于20% 的数据，1<= n,m <= 100
对于50% 的数据，1 <= n,m <= 2000
对于100% 的数据，1 <= n;m <= 100000; 1 <= a, b, x, y <= n; 1 <= z <= 10^9

分析

对于这类树上路径上的问题，一般考虑用树链剖分做。

对于一个操作，用树链剖分最多会把它分成$2logn$段，每一段都是一个连续的区间[l..r]，表示树上dfn为[l..r]的点。

然后每个点的答案跟其它点没有关系。所以我们可以离线读入所有操作，对于每一个都用树链剖分切成$2logn$段，然后对于该操作的所有区间[l..r]，把这个操作挂着dfn=l或者r的点上（分别标记为插入和删除）。然后从1到n枚举，对于dfn=i的点，先把插入的操作存下来，然后求个答案，最后把要删除的操作删去。这里可以用堆或线段树做。

时间复杂度$O(nlog^2n)$

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int maxn=100005,maxm=200005,maxt=262144,Log=18;

int n,m,tot,T,h[maxn],e[maxm],next[maxm],dfn[maxn],ch[maxn],top[maxn],t[maxt],A[maxn],size[maxn],fa[maxn][18],dep[maxn],v[maxn];

int ans[maxn],ID[maxn];

struct data
{ 
    int x,y,z;
}Q[maxn];

struct op
{
    int tot,h[maxn],e[maxm*20],next[maxm*20];
    void add(int x,int y)
    {
        e[++tot]=y; next[tot]=h[x]; h[x]=tot;
    }
}t1,t2;

bool cmp(int x,int y)
{
    return v[x]<v[y];
}

void add(int x,int y)
{
    e[++tot]=y; next[tot]=h[x]; h[x]=tot;
}

void init(int x)
{
    dep[x]=dep[fa[x][0]]+1;
    for (int i=h[x];i;i=next[i]) if (e[i]!=fa[x][0])
    {
        fa[e[i]][0]=x;
        init(e[i]);
        size[x]+=size[e[i]]+1;
    }
}

void dfs(int x)
{
    dfn[x]=++tot; ch[tot]=x; top[tot]=T;
    int j=0;
    for (int i=h[x];i;i=next[i]) if (e[i]!=fa[x][0] && (!j || size[j]<size[e[i]])) j=e[i];
    if (!j) return;
    dfs(j);
    for (int i=h[x];i;i=next[i]) if (e[i]!=fa[x][0] && e[i]!=j)
    {
        T=tot+1; dfs(e[i]);
    }
}

int getlca(int x,int y)
{
    if (dep[x]<dep[y]) x^=y^=x^=y;
    for (int i=Log-1;i>=0;i--) if (dep[fa[x][i]]>=dep[y]) x=fa[x][i];
    if (x==y) return x;
    for (int i=Log-1;i>=0;i--) if (fa[x][i]!=fa[y][i])
    {
        x=fa[x][i]; y=fa[y][i];
    }
    return fa[x][0];
}

void work(int x,int t,int v)
{
    if (dep[x]<=dep[t]) return;
    int j=dfn[x],k=top[j];
    if (k==top[dfn[t]]) k=dfn[t]+1;
    t1.add(k,v); t2.add(j,v);
    work(fa[ch[k]][0],t,v);
}

void Init(int l,int r,int x)
{
    t[x]=l;
    if (l==r) return;
    int mid=(l+r)/2;
    Init(l,mid,x*2); Init(mid+1,r,x*2+1);
}

void change(int l,int r,int g,int V,int x)
{
    if (l==r)
    {
        v[l]+=V; return;
    }
    int mid=(l+r)/2;
    if (g<=mid) change(l,mid,g,V,x*2);else change(mid+1,r,g,V,x*2+1);
    t[x]=(v[t[x*2]]>=v[t[x*2+1]])?t[x*2]:t[x*2+1];
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<n;i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        add(x,y); add(y,x);
    }
    init(1);
    for (int j=1;j<Log;j++)
        for (int i=1;i<=n;i++) fa[i][j]=fa[fa[i][j-1]][j-1];
    tot=0; T=1;
    dfs(1);
    for (int i=0;i<m;i++) scanf("%d%d%d",&Q[A[i]=i].x,&Q[i].y,&v[i]);
    sort(A,A+m,cmp);
    T=tot=0;
    for (int i=0;i<m;i++) Q[A[i]].z=(!i || v[A[i]]>v[A[i-1]])?++T:T,ID[T]=v[A[i]];
    for (int i=0;i<m;i++)
    {
        int lca=getlca(Q[i].x,Q[i].y);
        work(Q[i].x,lca,Q[i].z); work(Q[i].y,fa[lca][0],Q[i].z);
    }
    memset(v,0,sizeof(v));
    Init(1,T,1);
    for (int i=1;i<=n;i++)
    {
        for (int j=t1.h[i];j;j=t1.next[j]) change(1,T,t1.e[j],1,1);
        ans[ch[i]]=(v[t[1]])?ID[t[1]]:0;
        for (int j=t2.h[i];j;j=t2.next[j]) change(1,T,t2.e[j],-1,1);
    }
    for (int i=1;i<=n;i++) printf("%d\n",ans[i]);
    return 0;
}