loj2212 方伯伯的OJ

题意：

n<=1e8,m<=1e5.

标程：

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<map>
 using namespace std;
 int read()
 {
    int x=,f=;char ch=getchar();
    while (ch<''||ch>'') {if (ch=='-') f=-;ch=getchar();}
    while (ch>=''&&ch<='') x=(x<<)+(x<<)+ch-'',ch=getchar();
    return x*f;
 }
 const int N=;
 map<int,int> mp;
 int sz[N],son[N][],fa[N],L[N],R[N],tot,id[N],n,rt,m,mn,mx,ans,t,rk,x,y,op,g;
 void up(int x) {sz[x]=sz[son[x][]]+sz[son[x][]]+R[x]-L[x]+;}
 void rot(int &k,int x)
 {
     int y=fa[x],z=fa[y],l=(son[y][]==x),r=l^;
     if (y==k) k=x;else son[z][(son[z][]==y)]=x;
     fa[x]=z;fa[y]=x;fa[son[x][r]]=y;
    son[y][l]=son[x][r];son[x][r]=y;
    up(y);up(x);
 }
 void spl(int &k,int x)
 {
     for (int y;x!=k;rot(k,x))
       if ((y=fa[x])!=k)
         if (son[y][]==x^son[fa[y]][]==y) rot(k,x);else rot(k,y);
 }
 void ins(int &x,int l,int r,int idx,int f)//在splay的合适位置插入新区间
 {
    if (!x)
    {
        L[x=++tot]=l;R[tot]=r;id[tot]=idx;
        sz[tot]=r-l+;fa[tot]=f;
        return;
     }
     if (r<L[x]) ins(son[x][],l,r,idx,x);
     else ins(son[x][],l,r,idx,x);
     up(x);
 }
 void split(int x,int rk)
 {
     if (!son[x][]) rt=son[x][],fa[rt]=;//注意换根，保证splay连通
     else {
         int y=son[x][];
         while (son[y][]) y=son[y][];
         int z=son[x][];//注意转到根的下一个儿子处，不能转到根
         spl(z,y); rt=y;fa[rt]=;
         if (son[x][]) son[rt][]=son[x][];fa[son[x][]]=rt;
         up(rt);
     }
     if (L[x]<=rk-) {ins(rt,L[x],rk-,L[x],);spl(rt,tot);}//注意spl前也要判断
     if (rk+<=R[x]) {ins(rt,rk+,R[x],rk+,);spl(rt,tot);}
 }
 int find_rk(int x,int k)//查询rank为k的点(注意rank为k是离散的，不表示排在第k位）
 {
    if (L[x]<=k&&k<=R[x]) return x;
    if (k<L[x]) return find_rk(son[x][],k);
    else return find_rk(son[x][],k);
 }
 int qry_id(int x,int k)//查询rank_k的编号
 {
     if (k>sz[son[x][]]&&k<=sz[x]-sz[son[x][]])
     {
         if (L[x]==R[x]) return id[x];
         else return L[x]+(k-sz[son[x][]])-;
     }
     if (k<=sz[son[x][]]) return qry_id(son[x][],k);
     else return qry_id(son[x][],k-(sz[x]-sz[son[x][]]));
 }
 int main()
 {
     n=read();m=read();
     mn=;mx=n;ins(rt,,n,,);//mn从-1往下开始标号，以0来区分是否标记。
     while (m--)
     {
         op=read();x=read()-ans;
         if (op==) {printf("%d\n",ans=qry_id(rt,x));continue;}
         rk=mp[x];if (!rk) rk=x;
        g=find_rk(rt,rk); spl(rt,g);
         printf("%d\n",t=sz[son[g][]]+(rk-L[g]+));//离散排名转实际排名
        split(g,rk);
         if (op==)
         {
             y=read()-ans;
            ins(rt,rk,rk,y,);spl(rt,tot);
            mp[y]=rk;mp[x]=;
         }else
         {
             mp[x]=(op==)?--mn:++mx;
             ins(rt,mp[x],mp[x],x,);spl(rt,tot);
         }
         ans=t;
     }
    return ;
 }

易错点：果然又调了很久，不过感觉自己数据分析能力又提高了。。。

1.spl删点换根的时候注意把y旋转到x的右儿子处。如果把y旋转到x处，那么y的右儿子不一定是x，有可能是z，而z的左儿子是x。

2.注意删点函数split中ins之后的splay也要判断是否在区间限制内，反之有可能tot恰好是被删掉的那一个而产生死循环。

3.mn从-1往下开始标号，以0来区分是否标记。

题解：splay+离散排名+区间分裂

一道splay好题。

一开始在纠结怎么实现排名和编号的双转换？

用mp保存每个点的离散排名（就是给不连续参数代替排名）。splay按照实际排名构造，用sz可以查询区间rank_k。对于splay上的每个点保存一段离散排名区间L~R。

排名转编号：排名->sz查询rank_k的点。

编号转排名：编号->离散排名rk->查找该离散排名所在的splay点g->sz[son[g][0]]+rk-L[g]+1.

一般splay是无法保存下所有节点的。

对于动态修改操作，参考noipDay2T3的做法。

一开始只有一个节点。一个节点中保存编号连续的点L~R。如果L!=R，那么这一段的点都没有修改过。执行一个修改操作，就把原来的一个区间删除修改点断开成两个，再插入修改后的点。

对于2和3操作，如果往前面加入的点，离散排名设为--mn，往后加则是++mx。为了节省map空间，只对修改排名的点记录。

这样时空复杂度就只跟操作有关。

也可以建三棵树，往前面加就扔进1树，不变就在2树，往后面加就扔进3树。这样2树中元素太多，可以记录不在2树中的元素（取补）。好像也可以权值线段树。