【BZOJ】【1036】树的统计

　　嗯这题是一道对树进行动态修改&查询的经典题目，可以拿来练习树链剖分~

　　啊对于这种动态修改&查询的题目，我们最喜闻乐见的就是在一个序列上去做了，毕竟可以直接套各种数据结构模版啊，比如线段树、平衡树之类的。那么对于这种树上的动态修改&查询，我们可以把它通过一定的手段，“转化”成序列上的问题，再套用xx树之类的数据结构进行快速维护。而这个手段呢，就有很多种了（应该是吧？），这里用到的树链剖分，就是一种将树转化成序列的划分方式。

　　好的，我们现在拿到一棵树，首先我们会看到，这个树跟序列几乎没半点长的像的地方T_T，除非当这个坑爹的树刚好是一条链的形状……诶等等？链？对，就是那个极端情况下平衡树会退化成的那种样子 —— 一条链= = 联想到了什么？没错，我们可以把树拆成一条条链，嗯，我们可以这样想像一下：首先我们手里有一条链，然后我们再拿过来一条链，把它接在链中间的某个位置上，它就有了个分支，然后我们再接几条链上来，诶没错，它就成了一棵树！（怎么感觉有点像鸡毛掸子似的）

　　也就是说，我们可以将一棵树拆成几条链，平放在一条线上，它就成了一个序列了~

　　现在问题来了：怎么拆？首先我们在树上进行的查询，经常是对于两点间的【路径】的查询，那么我们肯定希望我们拆出来的链，尽可能是连续的大段，而不是细碎的小段，因为我们在用数据结构维护的时候，肯定是维护树上连续的链比较方便。而这种“长链”，就是在树链剖分中我们称之为【重链】的东西。但是，如果只有一条条重链也组不成一棵树啊，所以我们需要【轻链】来将重链连接起来，这样，我们对于树上所有的点和边，就都划分开了。

　　这个工作我们可以通过两次dfs来完成：一次dfs求出所有节点的father，son（这个son专指重儿子，重儿子的重儿子连下去组成重链），size，deep求出来……

　　（此处省略500字）好吧其实我还是有节操一点，把实现过程传送一下吧：http://blog.sina.com.cn/s/blog_6974c8b20100zc61.html

　　思想就是：路径可以划分为一条或多条重链的加和。（仅考虑【点】）

　　不在同一重链上，就往同一条重链上靠，这个是让深度大的往深度小的上面靠（想一想，为什么？），同时对深度大的重链上的值进行 维护or查询；如果在同一重链上，就回归了我们熟知的序列上的 维护or查询 问题了。

　　以下是BZOJ1036的代码：

 /**************************************************************
     Problem: 1036
     User: Tunix
     Language: C++
     Result: Accepted
     Time:2356 ms
     Memory:5612 kb
 ****************************************************************/
 
 //BZOJ 1036
 #include<vector>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<iostream>
 #include<algorithm>
 #define rep(i,n) for(int i=0;i<n;++i)
 #define F(i,j,n) for(int i=j;i<=n;++i)
 #define D(i,j,n) for(int i=j;i>=n;--i)
 #define pb push_back
 using namespace std;
 const int N=,INF=~0u>>;
 typedef long long LL;
 //#define debug
 struct Tree{
     int max,sum;
     #define L o<<1
     #define R o<<1|1
 }t[N<<];
 vector<int>G[N];
 int n,m;
 int tid[N],top[N],fa[N],son[N],dep[N],cnt,tot,size[N],a[N];
 bool vis[N];
 
 //从这里到undef为线段树上的操作
 #define mid (l+r>>1)
 inline void maintain(int o,int l,int r){
     t[o].max=t[o].sum=;
     if(l<r){
         t[o].max=max(t[L].max,t[R].max);
         t[o].sum=t[L].sum+t[R].sum;
     }
 }
 
 void updata(int o,int l,int r,int pos,int v){
     if (l==r) t[o].max=t[o].sum=v;
     else{
         if (pos<=mid) updata(L,l,mid,pos,v);
         if (pos>mid) updata(R,mid+,r,pos,v);
         maintain(o,l,r);
     }
 }
 int ql=,qr=;
 int _max,_sum;
 void query_it(int o,int l,int r){
     if (ql<=l && qr>=r){
         _max=max(_max,t[o].max);
         _sum+=t[o].sum;
     }
     else{
         if (ql<=mid) query_it(L,l,mid);
         if (qr>mid) query_it(R,mid+,r);
     }
 }
 
 #undef mid
 //线段树end
 
 void dfs(int x,int father,int deep){//第一次dfs
     vis[x]=;
     fa[x]=father; dep[x]=deep; size[x]=; son[x]=;
     int maxsize=;
     rep(i,G[x].size()){
         int to=G[x][i];
         if (vis[to]) continue;
         dfs(to,x,deep+);
         size[x]+=size[to];
         if (size[to]>maxsize) maxsize=size[to],son[x]=to;
     }
 }
 
 void connect(int x,int f){//第二次dfs，进行重链连接
     vis[x]=;
     tid[x]=++tot; top[x]=f;
     if (son[x]) connect(son[x],f);
 
     rep(i,G[x].size()){
         int to=G[x][i];
         if (!vis[to]) connect(to,to);
     }
 }
 
 void query(int x,int y){//树上查询
     while(top[x]!=top[y]){//如果不在同一重链上
         if (dep[top[x]]<dep[top[y]])
             swap(x,y);//找到深度大的
         ql=tid[top[x]]; qr=tid[x];
         query_it(,,n);//查询这条重链
         x=fa[top[x]];//往深度浅的靠
     }
     //直到在同一重链上，循环结束
     if (dep[x]>dep[y]) swap(x,y);
     ql=tid[x]; qr=tid[y];
     query_it(,,n);//查询这段区间
 }
 
 int main(){
     #ifndef ONLINE_JUDGE
     freopen("file.in","r",stdin);
 //    freopen("file.out","w",stdout);
     #endif
     int x,y;
     scanf("%d",&n);
     F(i,,n){
         scanf("%d%d",&x,&y);
         G[x].pb(y);
         G[y].pb(x);
     }
     F(i,,n) scanf("%d",&a[i]);
     memset(vis,,sizeof vis);
     dfs(,,);
     memset(vis,,sizeof vis);
     connect(,);
     F(i,,n) updata(,,n,tid[i],a[i]);
 
     scanf("%d",&m);
     char cmd[];
     F(i,,m){
         scanf("%s%d%d",cmd,&x,&y);
         if (cmd[]=='H')
             updata(,,n,tid[x],y);
         else{
             _sum=;
             _max=-INF;
             query(x,y);
             if(cmd[]=='M') printf("%d\n",_max);
             else printf("%d\n",_sum);
         }
     }
     return ;
 }
 /******************************************************
 树链剖分啊，感觉上也是一种把树转化为序列进行操作的过程
 一棵树不好存，就拆成一条条链，平放在一起就成了一个序列
 然后根据一定的方式来拆，可以保证链的数量尽量少(log(n))
 然后就可以用序列操作的方式，对树进行操作了！
 ******************************************************/