　　此题可以看作平衡树的一个大模板，由于是区间问题，所以用splay或者fhqtreap，我用了fhqtreap（写起来太舒服了）。

　　输入数据一定是正确的，即指定位置的数在数列中一定存在。

　　100%的数据中，任何时刻数列中任何一个数字均在[-1 000, 1 000]内。

　　100%的数据中，M ≤20 000，插入的数字总数不超过 4 000 000 。

　　1.插入和删除tot个数：因为这题时间卡的很紧，所以不能使用比较方便的那种O(nlogn)方式插入，因为此题是区间，所以插入的数据必是单调插入，所以此处使用笛卡尔树的建树方式，复杂度为O(n)，因为需要用到栈，此处建议手写栈，STL太慢了（STL一生黑QAQ，真香）。这题还得用读入优化，不知是。删除的话直接将区间提取出来删掉就可以了。但是，此处有个问题，删除的空间需要回收，因为只有128M内存，貌似最多也就开1e6，但是，数据范围告诉了数列中最多有5e5个数字，所以删除的时候就要求空间回收，下次插入的时候要插到这些空间中（再来个栈就完事了，小问题）。

　　2.修改和反转：像线段树一样就好了，打个标记，然后再访问的时候往下推。

　　3.求和求最大子序列，维护sum,lmax,rmax,mmax就行了。（%%%）

二、P2596 [ZJOI2006]书架

　　这题最大的问题就是要根据区间的内的编号来找到点的排名，记录父节点，记录每个值所在点的编号，然后递归求rank即可

三、P3285 [SCOI2014]方伯伯的OJ

　　无力吐槽，此题动态开点。。。debug了一整天，代码漏洞颇多。。。。QAQ

　　此题一个收获：对于一段区间都要映射到某个值，可以取这个区间的最大值，将之映射（m）于val，然后对于一个节点k，m.lower_bound(k)->second就是这个val。

  1 #include<bits/stdc++.h>
  2 using namespace std;
  3 const int MAX=3e5+100,INF=0x7fffffff;
  4 struct ppp{
  5     int ch[2],rnd,size,l,r,fa;
  6 }treap[MAX];
  7 map<int,int> f;
  8 int n,m,a,tot,root,lnow=INF,cnt=0;
  9  void update(int p)
 10 {
 11     treap[p].size=treap[treap[p].ch[0]].size+treap[treap[p].ch[1]].size+treap[p].r-treap[p].l+1;
 12     treap[treap[p].ch[0]].fa=treap[treap[p].ch[1]].fa=p;
 13     treap[0]=(ppp){0,0,0,0,0,0,0};
 14 }
 15  int divide(int now,int k)//now保留前k个 
 16 {
 17     if(k==treap[now].r-treap[now].l+1)    return 0;
 18     if(k==0)    return now; 
 19     tot++;
 20     treap[tot]=(ppp){0,0,rand(),0,treap[now].l+k,treap[now].r,0};
 21     
 22     f[treap[now].r]=tot;
 23     f[treap[now].l+k-1]=now;
 24 
 25     treap[now].r=treap[now].l+k-1;
 26     treap[tot].ch[1]=treap[now].ch[1];
 27     if(treap[now].rnd<treap[tot].rnd)//tot防在右下角 
 28     {
 29         treap[now].ch[1]=tot;
 30         update(tot);
 31         update(now);
 32     }
 33     else
 34     {
 35         treap[now].ch[1]=0;
 36         treap[tot].ch[0]=now;
 37         treap[tot].fa=treap[now].fa;
 38         treap[treap[now].fa].ch[treap[treap[now].fa].ch[1]==now?1:0]=tot;
 39         update(now);
 40         update(tot);
 41         update(treap[tot].fa);
 42     }
 43     if(treap[tot].fa==0)    root=tot;
 44     return tot;
 45 }
 46  int merge(int x,int y)
 47 {
 48     if(x==0 or y==0)
 49         return x+y;
 50     if(treap[x].rnd>treap[y].rnd)
 51     {
 52         treap[y].ch[0]=merge(x,treap[y].ch[0]);
 53         update(y);
 54         return y;
 55     }
 56     else
 57     {
 58         treap[x].ch[1]=merge(treap[x].ch[1],y);
 59         update(x);
 60         return x;
 61     }
 62 }
 63  void split(int now,int &x,int &y,int rank)
 64 {   
 65     if(rank==0)
 66     {
 67         treap[now].fa=treap[y].fa;
 68         x=0,y=now;
 69         return ;
 70     }
 71     if(rank>=treap[now].size)
 72     {
 73         treap[now].fa=treap[x].fa;
 74         x=now,y=0;
 75         return ;
 76     }
 77     if(treap[treap[now].ch[0]].size>=rank)
 78     {
 79         treap[now].fa=treap[y].fa;
 80         y=now;
 81         split(treap[now].ch[0],x,treap[now].ch[0],rank);
 82         update(now);
 83     }
 84     else if(treap[treap[now].ch[0]].size+treap[now].r-treap[now].l+1<=rank)
 85     {
 86         treap[now].fa=treap[x].fa;
 87         x=now;
 88         split(treap[now].ch[1],treap[now].ch[1],y,rank-(treap[treap[now].ch[0]].size+treap[now].r-treap[now].l+1));
 89         update(now);
 90     }
 91     else
 92     {
 93         int ori_fa=treap[now].fa; 
 94         int k=divide(now,rank-treap[treap[now].ch[0]].size-1);
 95         int q=divide(k,1);
 96         while(treap[now].fa!=ori_fa)
 97             now=treap[now].fa;
 98         split(now,x,y,rank);
 99     }
100 }
101  void init()
102 {
103     root=++tot;
104     treap[root]=(ppp){0,0,rand(),n,1,n,0};
105     f[n]=root;
106 }
107  int find(int p)
108 {
109     int fa=treap[p].fa;
110     if(fa==0 or p==0 or p==fa)    return 0;
111     int son=treap[fa].ch[1]==p;
112     if(son)    return treap[treap[fa].ch[0]].size+treap[fa].r-treap[fa].l+1+find(fa);
113     else    return find(fa);
114 }
115  int getrank(int x)
116 {
117     map<int,int>::iterator it=f.lower_bound(x);
118     int p=it->second;
119     return find(p)+treap[treap[p].ch[0]].size+x-treap[p].l+1;
120 }
121 int main()
122 {
123     scanf("%d%d",&n,&m);
124     init();
125     for(int i=1;i<=m;i++)
126     {
127         int opt,x1,y1;
128         scanf("%d%d",&opt,&x1);
129         x1-=a;
130         if(opt==1)
131         {
132             scanf("%d",&y1);
133             y1-=a;
134             int rank=getrank(x1);
135             printf("%d
",rank);
136             a=rank;
137             int x=0,y=0,z=0;
138             split(root,x,y,rank-1);
139             split(y,z,y,1);
140             treap[z].l=treap[z].r=y1;
141             f[y1]=z;
142             f.erase(x1);
143             root=merge(merge(x,z),y);
144         }
145         else if(opt==2)
146         {
147             int rank=getrank(x1);
148             printf("%d
",rank);
149             a=rank;
150             int x=0,y=0,z=0;
151             split(root,x,y,rank-1);
152             split(y,z,y,1);
153             root=merge(merge(z,x),y);
154         }
155         else if(opt==3)
156         {
157             int rank=getrank(x1);
158             printf("%d
",rank);
159             a=rank;
160             int x=0,y=0,z=0;
161             split(root,x,y,rank-1);
162             split(y,z,y,1);
163             root=merge(merge(x,y),z);
164         }
165         else if(opt==4)
166         {
167             int x=0,y=0,z=0;
168             split(root,x,y,x1-1);
169             split(y,z,y,1);
170             a=treap[z].l;
171             printf("%d
",a);
172             root=merge(merge(x,z),y);
173         }
174     }
175     return 0;
176 }

View Code

四、P3765 总统选举

　　此题需要维护一个出现次数>1/2的区间众数，神奇的方法：摩尔比较法。利用线段树维护可能的众数，然后利用平衡树去判断，此众数是否符合要求。

　　如果说，是一般的区间众数，貌似只能用分块乱搞。

  1 #include<bits/stdc++.h>
  2 using namespace std;
  3 const int MAX=5e5+2;
  4 struct ppp{
  5     int cnt,cand;
  6 }tree[MAX<<2];
  7 struct iop{
  8     int val,ch[2],size,rnd;
  9 }treap[MAX<<1];
 10 int root[MAX],tot,n,m,pic[MAX],modify[MAX<<1];//pic ÏÈÓÃÓÚ´¢´æÔÍ¼£¬ºóÓÃÓÚ´æÈ¡Ïß¶ÎÊ÷½Úµã±àºÅ 
 11 inline void up(int node)
 12 {
 13     if(tree[node<<1].cand==tree[(node<<1)|1].cand)
 14     {
 15         tree[node].cand=tree[node<<1].cand;
 16         tree[node].cnt=tree[node<<1].cnt+tree[(node<<1)|1].cnt;
 17     }
 18     else
 19     {
 20         if(tree[node<<1].cnt>=tree[(node<<1)|1].cnt) 
 21             tree[node].cnt=tree[node<<1].cnt-tree[(node<<1)|1].cnt,tree[node].cand=tree[node<<1].cand;
 22         else 
 23             tree[node].cnt=tree[(node<<1)|1].cnt-tree[node<<1].cnt,tree[node].cand=tree[(node<<1)|1].cand;
 24     }
 25 }
 26 void build(int node,int l,int r)
 27 {
 28     if(l==r)
 29     {
 30         tree[node].cand=pic[l];
 31         tree[node].cnt=1;
 32         pic[l]=node;
 33         return;
 34     }
 35     else
 36     {
 37         int mid=(l+r)>>1;
 38         build(node<<1,l,mid);
 39         build((node<<1)|1,mid+1,r);
 40         up(node);
 41     }
 42 }
 43 inline ppp find(int node,int l,int r,int L,int R)
 44 {
 45     int mid=(L+R)>>1;
 46     if(l==L and r==R)    return tree[node];
 47     if(r<=mid)
 48         return find(node<<1,l,r,L,mid);
 49     else if(l>mid)
 50         return find((node<<1)|1,l,r,mid+1,R);
 51     else
 52     {
 53         ppp a=find(node<<1,l,mid,L,mid);
 54         ppp b=find((node<<1)|1,mid+1,r,mid+1,R);
 55         ppp c;
 56         if(a.cand==b.cand)    
 57             c.cnt=a.cnt+b.cnt,c.cand=a.cand;
 58         else
 59         {
 60             if(a.cnt>=b.cnt) c.cnt=a.cnt-b.cnt,c.cand=a.cand;
 61             else c.cnt=b.cnt-a.cnt,c.cand=b.cand;
 62         }
 63         return c;
 64     }
 65 }
 66 inline void update(int p)
 67 {
 68     treap[p].size=treap[treap[p].ch[0]].size+treap[treap[p].ch[1]].size+1;
 69 }
 70 inline int NEW(int val)
 71 {
 72     tot++;
 73     treap[tot]=(iop){val,0,0,1,rand()};
 74     return tot;
 75 }
 76 inline int merge(int x,int y)
 77 {
 78     if(x==0 or y==0 )
 79         return x+y;
 80     if(treap[x].rnd<treap[y].rnd)
 81     {
 82         treap[x].ch[1]=merge(treap[x].ch[1],y);
 83         update(x);
 84         return x;
 85     }
 86     else
 87     {
 88         treap[y].ch[0]=merge(x,treap[y].ch[0]);
 89         update(y);
 90         return y;
 91     }
 92 }
 93 inline void split(int now,int &x,int &y,int val)
 94 {
 95     if(now==0)
 96     {
 97         x=0,y=0;
 98         return ;
 99     }
100     if(treap[now].val<=val)
101     {
102         x=now;
103         split(treap[now].ch[1],treap[now].ch[1],y,val);
104     }
105     else
106     {
107         y=now;
108         split(treap[now].ch[0],x,treap[now].ch[0],val);
109     }
110     update(now);
111 }
112 inline bool check(int l,int r,int cad)
113 {
114     if(root[cad]==0)
115         return false;
116     int x,y,z;
117     split(root[cad],x,y,l-1);
118     split(y,y,z,r); 
119     bool ans=(treap[y].size<<1)>(r-l+1);
120     root[cad]=merge(merge(x,y),z);
121     return ans;
122 }
123 inline void change(int voter,int cad)
124 {
125     //------------------------------treap
126     int ori=tree[pic[voter]].cand;
127     int x,y,z;
128     split(root[ori],x,y,voter-1);
129     split(y,y,z,voter);
130     root[ori]=merge(x,z);
131     split(root[cad],x,z,voter-1);
132     root[cad]=merge(merge(x,y),z);
133     //-----------------------------segment_tree
134     int node=pic[voter];
135     tree[node].cand=cad;
136     node>>=1;
137     while(node)
138     {
139         up(node);
140         node>>=1;
141     }
142 }
143 int main()
144 {
145     scanf("%d%d",&n,&m);
146     for(int i=1;i<=n;i++)
147     {
148         scanf("%d",&pic[i]);
149         int p=NEW(i);
150         if(!root[pic[i]])
151             root[pic[i]]=p;
152         else
153             root[pic[i]]=merge(root[pic[i]],p);
154     }
155     build(1,1,n);
156     for(int i=1;i<=m;i++)
157     {
158         int l,r,s,k;
159         scanf("%d%d%d%d",&l,&r,&s,&k);
160         for(int j=1;j<=k;j++)
161             scanf("%d",&modify[j]);
162         int cad=find(1,l,r,1,n).cand;
163         if(check(l,r,cad))    
164             s=cad;
165         for(int j=1;j<=k;j++)
166             change(modify[j],s);
167         printf("%d
",s);
168     }
169     int winner=-1;
170     for(int i=1;i<=n;i++)
171         if((treap[root[i]].size<<1)>n)    winner=i;
172     printf("%d",winner);
173     return 0;
174 }

View Code

平衡树有关题目小结

一、P2042 [NOI2005]维护数列

二、P2596 [ZJOI2006]书架

三、P3285 [SCOI2014]方伯伯的OJ

四、P3765 总统选举

五、咕咕咕。。。。