BZOJ3720 Gty的妹子树

Description

我曾在弦歌之中听过你，

檀板声碎，半出折子戏。

舞榭歌台被风吹去，

岁月深处尚有余音一缕……

Gty神(xian)犇(chong)从来不缺妹子……

他来到了一棵妹子树下，发现每个妹子有一个美丽度……

由于Gty很哲♂学，他只对美丽度大于某个值的妹子感兴趣。

他想知道某个子树中美丽度大于k的妹子个数。

某个妹子的美丽度可能发生变化……

树上可能会出现一只新的妹子……

维护一棵初始有n个节点的有根树(根节点为1)，树上节点编号为1-n，每个点有一个权值wi。

支持以下操作：

0 u x          询问以u为根的子树中，严格大于x的值的个数。(u^=lastans,x^=lastans)

1 u x          把u节点的权值改成x。(u^=lastans,x^=lastans)

2 u x          添加一个编号为"当前树中节点数+1"的节点，其父节点为u，其权值为x。(u^=lastans,x^=lastans)

最开始时lastans=0。

Input

输入第一行包括一个正整数n(1<=n<=30000)，代表树上的初始节点数。

接下来n-1行，每行2个整数u,v，为树上的一条无向边。

任何时刻，树上的任何权值大于等于0，且两两不同。

接下来1行，包括n个整数wi，表示初始时每个节点的权值。

接下来1行，包括1个整数m(1<=m<=30000)，表示操作总数。

接下来m行，每行包括三个整数 op,u,v：

op,u,v的含义见题目描述。

保证题目涉及的所有数在int内。

Output

对每个op=0，输出一行，包括一个整数，意义见题目描述。

Sample Input

2
1 2
10 20
1
0 1 5

Sample Output

2

正解：块状树

解题报告：

　　遥遥昨天讲了许多神奇的数据结构，比如这道题用的块状树，个人感觉就是在树上分块。。。

　　大概讲一下块状树的思想和用法吧。考虑我们将树上的某一些点变成一个连通块，然后每个块中分别处理（内部都是暴力处理），如果碰到可以整块处理的就整块处理。

　　每个块都记录一下块内的权值，按顺序排列。块与块之间有连边。

　　感觉跟分块真的很像。。。第一遍DFS的时候看一下父亲所在的块是否已经满了（设置为块的上限，在根号左右最佳），如果满了的话就新建一个块，并且把新建的块与父亲所在的块连边，否则加入父亲所在的块。每次插入，在块内部都是暴力处理。修改操作也是在块内暴力处理，修改完之后暴力移动，保证有序性。新的插入也是一样的，与第一遍DFS相同，只需看一下父亲所在块是不是满了。查询的话就DFS，发现儿子结点与自己所在块不同，就直接访问整个块，二分查找块内大于需查询的值的个数。

　　这道题有很多细节要注意，调了一个多小时，中间经历了WA、RE、TLE、MLE，也是醉了。

 //It is made by jump~
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
 #include <cmath>
 #include <algorithm>
 #include <ctime>
 #include <vector>
 #include <queue>
 #include <map>
 #include <set>
 #ifdef WIN32
 #define OT "%I64d"
 #else
 #define OT "%lld"
 #endif
 using namespace std;
 typedef long long LL;
 const int MAXN = ;
 const int S = ; //实验表明，400附近最合适。。。
 int n,ecnt,cnt;
 int w[MAXN],father[MAXN];
 int first[MAXN],next[MAXN*],to[MAXN*];
 int ans,m;
 int belong[MAXN];
 int head[MAXN];

 inline int getint()
 {
        int w=,q=;
        char c=getchar();
        while((c<'' || c>'') && c!='-') c=getchar();
        if (c=='-')  q=, c=getchar();
        while (c>='' && c<='') w=w*+c-'', c=getchar();
        return q ? -w : w;
 }

 struct kuai_tree{
     int size; int a[S+];

     inline void insert(int x){//块内暴力插入新元素
     size++; int i=size;
     for(;i>=;i--) if(a[i-]>x) a[i]=a[i-]; else break;
     a[i]=x;
     }

     inline int zuo_ask(int x){//查找到相等的值的最左一位
     int l=,r=size,mid;
     while(l<=r) {
         mid=(l+r)/;
         if(a[mid]>=x) r=mid-;
         else l=mid+;
     }
     return l;//!!!
     }

     inline int you_ask(int x){//查找到相等的值的最右一位
     int l=,r=size,mid;
     while(l<=r) {
         mid=(l+r)/;
         if(a[mid]>x) r=mid-;
         else l=mid+;
     }
     return r;//!!!
     }

     inline void update(int x,int y){//块内暴力更改
     int i=zuo_ask(x);
     for(;i<size && a[i+]<y;i++) a[i]=a[i+];
     for(;i> && a[i-]>y;i--) a[i]=a[i-];//无需等号
     a[i]=y;
     }

     inline int query(int x){
     return size-you_ask(x);
     }
 }tr[MAXN];

 inline void link(int x,int y){ next[++ecnt]=head[x]; head[x]=ecnt; to[ecnt]=y; }

 inline void dfs(int x,int fa){
     if(tr[belong[fa]].size==S) {cnt++; belong[x]=cnt; link(belong[fa],cnt); tr[cnt].insert(w[x]);}//是belong而不是本身！！！ 是cnt而不是本身
     else { belong[x]=belong[fa]; tr[belong[fa]].insert(w[x]); }
     father[x]=fa;
     for(int i=first[x];i;i=next[i]) {
     int v=to[i];
     if(v==fa) continue;
     dfs(v,x);
     }
 }

 inline void kuai_DFS(int x,int num){
     ans+=tr[x].query(num);
     for(int i=head[x];i;i=next[i]) kuai_DFS(to[i],num);
 }

 inline void DFS(int x,int num){
     if(w[x]>num) ans++;
     for(int i=first[x];i;i=next[i]) {
     int v=to[i];
     if(v==father[x]) continue;
     if(belong[x]==belong[v]) DFS(v,num);
     else kuai_DFS(belong[v],num);
     }
 }

 inline void work(){
     n=getint();  int x,y;
     for(int i=;i<n;i++) {
     x=getint(); y=getint();
     next[++ecnt]=first[x]; first[x]=ecnt; to[ecnt]=y;
     next[++ecnt]=first[y]; first[y]=ecnt; to[ecnt]=x;
     }
     for(int i=;i<=n;i++) w[i]=getint();
     tr[].size=S; dfs(,);
     m=getint(); int ljh;
     for(int i=;i<=m;i++) {
     ljh=getint(); x=getint(); y=getint();
     x=x^ans; y=y^ans;
     if(ljh==) { ans=; DFS(x,y); printf("%d\n",ans); }
     else if(ljh==) { tr[belong[x]].update(w[x],y); w[x]=y; }
     else{
         w[++n]=y; father[n]=x;  next[++ecnt]=first[x]; first[x]=ecnt; to[ecnt]=n;//都要连接一下
         if(tr[belong[x]].size==S) {
         cnt++; tr[cnt].insert(y); belong[n]=cnt;
         link(belong[x],cnt);
         }
         else{
         belong[n]=belong[x];
         tr[belong[x]].insert(y);
         }
     }
     }
 }

 int main()
 {
   work();
   return ;
 }