BZOJ 3307 雨天的尾巴 (树上差分+线段树合并)

题目大意：给你一棵树，树上一共n个节点，共m次操作，每次操作给一条链上的所有节点分配一个权值，求所有节点被分配到所有的权值里，出现次数最多的权值是多少，如果出现次数相同就输出最小的。

(我辣鸡bzoj的权限号，洛谷上P4556也有这道题)

线段树合并入门题

也是比较常规的树上链的点差分 每次操作都在x,y上+1，在lca(x,y)，fa[lca(x,y)]上-1

然后对每个点的所有差分操作构建一颗动态开点线段树，然后从叶节点向上合并即可

特别的，只有线段树的最底层存的是实际打的差分，而上层节点仅仅是用来 像分治一样在log(n)时间内 快速求得答案，所以最底层和上层所维护的东西也不一样。所以合并的过程中，两棵树的最底层节点是直接相加，而上层是通过下层来更新答案，而并非对这两个线段树直接合并，需要仔细思考。

总结：树上线段树合并 恰好和 树上主席树 相反

树上线段树合并是回溯时由子节点更新父节点的线段树

而树上主席树是通过深搜从父节点更新子节点的线段树

 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 #define inf 0x3f3f3f3f
 #define ll long long
 #define N 100100
 #define maxn 1000000
 using namespace std;
 //re
 int n,m,cte,tot,num;
 int head[N],dep[N],fa[N],tp[N],sz[N],son[N],root[N],a[N],ans[N];
 int ls[N*],rs[N*];
 struct Ques{
     int x,y,w,ff;
 }ques[N];
 struct node{
     int id,sum;
 }ma[N*];
 struct EDGE{
     int to,nxt;
 }edge[N*];
 void ae(int u,int v)
 {
     cte++;
     edge[cte].to=v;
     edge[cte].nxt=head[u];
     head[u]=cte;
 }
 int gc()
 {
     int rett=,fh=;char p=getchar();
     while(p<''||p>'') {if(fh=='-')fh=;p=getchar();}
     while(p>=''&&p<='') {rett=(rett<<)+(rett<<)+p-'';p=getchar();}
     return rett*fh;
 }
 void tcs_dfs1(int x,int dad)
 {
     for(int j=head[x];j!=-;j=edge[j].nxt){
         int v=edge[j].to;
         if(v==dad) continue;
         dep[v]=dep[x]+,fa[v]=x;
         tcs_dfs1(v,x),sz[x]+=sz[v];
         son[x]=(sz[v]>sz[son[x]])?v:son[x];
     }sz[x]++;
 }
 void tcs_dfs2(int x)
 {
     root[x]=++tot;
     if(son[x]) tp[son[x]]=tp[x],tcs_dfs2(son[x]);
     for(int j=head[x];j!=-;j=edge[j].nxt){
         int v=edge[j].to;
         if(v==fa[x]||v==son[x]) continue;
         tp[v]=v,tcs_dfs2(v);
     }
 }
 int LCA(int x,int y)
 {
     while(tp[x]!=tp[y]){
         if(dep[tp[x]]<dep[tp[y]]) swap(x,y);
         x=fa[tp[x]];
     }return dep[x]<dep[y]?x:y;
 }
 void seg_modify(int x,int l,int r,int rt,int w)
 {
     if(l==r){ma[rt].sum+=w,ma[rt].id=l;return;}
     int mid=(l+r)>>;
     if(x<=mid) seg_modify(x,l,mid,ls[rt]?ls[rt]:(ls[rt]=++tot),w);
     else seg_modify(x,mid+,r,rs[rt]?rs[rt]:(rs[rt]=++tot),w);
     if(ma[ls[rt]].sum>ma[rs[rt]].sum) ma[rt].id=ma[ls[rt]].id;
     else if(ma[ls[rt]].sum<ma[rs[rt]].sum) ma[rt].id=ma[rs[rt]].id;
     else ma[rt].id=min(ma[ls[rt]].id,ma[rs[rt]].id);
     ma[rt].sum=max(ma[ls[rt]].sum,ma[rs[rt]].sum);
 }
 int seg_merge(int rx,int ry,int l,int r)
 {
     if(!rx||!ry) return rx+ry;
     if(l==r){
         ma[rx].sum+=ma[ry].sum;ma[rx].id=l;
         return rx;}
     int mid=(l+r)>>;
     ls[rx]=seg_merge(ls[rx],ls[ry],l,mid);
     rs[rx]=seg_merge(rs[rx],rs[ry],mid+,r);
     if(ma[ls[rx]].sum>ma[rs[rx]].sum) ma[rx].id=ma[ls[rx]].id;
     else if(ma[ls[rx]].sum<ma[rs[rx]].sum) ma[rx].id=ma[rs[rx]].id;
     else ma[rx].id=min(ma[ls[rx]].id,ma[rs[rx]].id);
     ma[rx].sum=max(ma[ls[rx]].sum,ma[rs[rx]].sum);
     return rx;
 }
 void dfs_ans(int x)
 {
     for(int j=head[x];j!=-;j=edge[j].nxt){
         int v=edge[j].to;
         if(v==fa[x]) continue;
         dfs_ans(v);
         seg_merge(root[x],root[v],,num);
     }
     ans[x]=ma[root[x]].id;
 }

 int main()
 {
     //freopen("data.in","r",stdin);
     scanf("%d%d",&n,&m);
     memset(head,-,sizeof(head));
     int x,y,z,ff;
     for(int i=;i<n;i++)
         x=gc(),y=gc(),ae(x,y),ae(y,x);
     dep[]=,tcs_dfs1(,-);
     tp[]=,tcs_dfs2();
     for(int i=;i<=m;i++)
     {
         ques[i].x=gc(),ques[i].y=gc();
         ques[i].w=gc(),ques[i].ff=LCA(ques[i].x,ques[i].y);
         a[++num]=ques[i].w;
     }
     sort(a+,a+num+);
     num=unique(a+,a+num+)-(a+);
     for(int i=;i<=m;i++)
     {
         int ww=lower_bound(a+,a+num+,ques[i].w)-a;
         seg_modify(ww,,num,root[ques[i].x],);
         seg_modify(ww,,num,root[ques[i].y],);
         seg_modify(ww,,num,root[ques[i].ff],-);
         if(fa[ques[i].ff]) seg_modify(ww,,num,root[fa[ques[i].ff]],-);
     }
     dfs_ans();
     for(int i=;i<=n;i++) printf("%d\n",a[ans[i]]);
     return ;
 }