雨天的尾巴题解

1. 源自BZOJ3307的雨天的尾巴，是一道很好的图论题，结合了树上差分，离散化，权值线段树动态开点和线段树合并的知识，非常适合作为例题对概念进行理解。
2. 题目：有 N (N≤10^5) 个点，形成一个树状结构。
   有 M (M≤10^5) 次发放操作，每次选择两个点 x,y，对 x 到 y 的路径上（包括 x,y）的每个点发放一袋 z (z≤10^9) 类型的物品。
   求完成所有发放操作后，每个点存放最多的是哪种类型的物品。
   3.思路分析：本篇题解是将z的范围当作1～100000来写的，所以省略了离散化的过程。首先对题目进行分析。
   （1）本题要求在树上，对x～y路径上的所有点加一个数z，求每个点所加的最多的数的值。
   （2）区间修改，求单点数量最多的数，很容易想到权值线段树。
   （3）又因为本题是在树上对路径修改，很容易想到与区间修改对应的差分，区间操作对应为路径操作，前缀和对应为子树和。根据题意，对x～y上路径所有的点加一个数z，则是在x，y处产生z，在lca（x，y）初消失z，在fa【lca（x，y）】处消失z。
   （4）为了节省空间，我们采用动态开点的权值线段树。其中lc，rc维护左右节点，（因为动态开点，所以左右子树不一定满足2倍关系）。其次，每个点还具有一个big，代指这个点对应数量最多的数的数量是多少，一个now-big，代指这个点对应数量最多的数是几。用up（）函数维护每一次向上更新的操作。merge（）函数进行线段树的合并操作。calc（）函数通过深度优先遍历，把每个节点所建的权值线段树进行合并即可。
   4.贴上代码

#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
int n,m;
vector<int>son[100010];
int v[100010];

int f[100010][30];
int t;
int d[100010];

int gen[100010];
int ans[100010];
queue<int>q;

struct SegmentTree{
    int lc,rc;
    int big;
    int now_big;
}tr[100010*50];
int tot=0;

void up(int k)
{
    if (tr[tr[k].lc].big>=tr[tr[k].rc].big)
    {
        tr[k].big=tr[tr[k].lc].big;
        tr[k].now_big=tr[tr[k].lc].now_big;
    }
    else{
        tr[k].big=tr[tr[k].rc].big;
        tr[k].now_big=tr[tr[k].rc].now_big;
    }
}
void insert(int &k,int l,int r,int val,int num)
{
    if (!k) k=++tot;
    if (l==r)
    {
        tr[k].big+=num;
        tr[k].now_big=l;
        return;
    }
    int mid=(l+r)>>1;
    if (val<=mid) {
        insert(tr[k].lc,l,mid,val,num); 
    }
    else{
        insert(tr[k].rc,mid+1,r,val,num);
    }
    up(k);
    return;
}
int merge(int p,int q,int l,int r)
{
    if (!p||!q) return p+q;
    if (l==r)
    {
        tr[p].big+=tr[q].big;
        tr[p].now_big=l;
        return p;
    }
    int mid=(l+r)>>1;
    tr[p].lc=merge(tr[p].lc,tr[q].lc,l,mid);
    tr[p].rc=merge(tr[p].rc,tr[q].rc,mid+1,r);
    up(p);
    return p;
}
void calc(int root)
{
    for (int i=0;i<son[root].size();i++)
    {
        int to=son[root][i];
        if (to==f[root][0]) continue;
        calc(to);
        gen[root]=merge(gen[root],gen[to],1,100000);
    }
    if (tr[gen[root]].now_big) ans[root]=tr[gen[root]].now_big;
    else ans[root]=0;
}
void bfs(int root)
{
    q.push(root);
    d[root]=1;
    while (!q.empty())
    {
        int now=q.front();
        q.pop();
        for (int i=0;i<son[now].size();i++)
        {
            int to=son[now][i];
            if (d[to]) continue;
            d[to]=d[now]+1;
            f[to][0]=now;
            for (int j=1;j<=t;j++)
            {
                f[to][j]=f[f[to][j-1]][j-1];
            }
            q.push(to);
        }
    }
    return;
}
int lca(int now,int to)
{
    if (d[now]>d[to]) swap(now,to);
    for (int i=t;i>=0;i--)
    {
        if (d[f[to][i]]>=d[now]) to=f[to][i];
    }
    if (to==now) return now;
    for (int i=t;i>=0;i--)
    {
        if (f[now][i]!=f[to][i]) now=f[now][i],to=f[to][i];
    }
    return f[now][0];
}

int main()
{
    //freopen("acmin.txt","r",stdin);
    //freopen("acmout.txt","w",stdout);
    cin>>n>>m;
    t=(int)(log(n)/log(2))+1;
    int a,b;
    for (int i=1;i<n;i++)
    {
        scanf("%d%d",&a,&b);
        son[b].push_back(a);
        son[a].push_back(b);
    }
    int x,y,z;
    bfs(1);
    //for(int i=1;i<=n;i++) cout<<f[i][0]<<endl;
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        int fa=lca(x,y);
        insert(gen[x],1,100000,z,1);
        insert(gen[y],1,100000,z,1);
        insert(gen[fa],1,100000,z,-1);
        insert(gen[f[fa][0]],1,100000,z,-1);
    }
    calc(1);
    for (int i=1;i<=n;i++) 
    {
        printf("%d\n",ans[i]);
    }
    return 0;

}

提示：因为每个节点都会建立一个线段树，所以gen【i】代表节点i建立的线段树的根节点的tot值。