SGU 187 - Twist and whirl -- want to cheat

原题地址：http://acm.sgu.ru/problem.php?contest=0&problem=187

太开心啦！！！！这道题从2013年开始困扰我！！今天晚上第四次下定决心把它写一写，之前写了三次（事实上是五个程序）都没有把它搞定，甚至无从查错……没想到今晚居然1A啦太激动了喵哈哈～我先去激动一会

题目大意：给定一个数字n，构建一个从1 ~ n的初始数列，给出 m 个操作，每个操作对应两个数字 x 和 y 每次将当前序列中的第 x 位到第 y 位翻转，输出最终的序列

数据范围和限制：1<=N<=130000, 1<=M<=2000， 时间限制0.25s, 内存限制 4M（这……）

题目分析：这题貌似是改过数据范围或者内存限制，反正网上很多大牛直接建了一棵 n 的节点的伸展树，然后进行区间翻转，但是现在的数据范围必然导致MLE。但是这并不意味着伸展树无计可施我们需要另寻它路。hockey传授的解法是这样的：将每个区间视为一个点( 记作[l, r] )，在需要对它的子区间 [i, j] 进行翻转操作时，我们将它拆成三个点 [l, i]、[i, j]、[j, r]，然后在[i, j]上打上翻转标记……

一般地来讲就是这样：我们的Splay是由若干个区间组成的，当我们需要翻转区间[i, j]时，先查找出 i - 1 在当前树中的哪个区间上，然后将它拆成左右两个区间（约定我们拆分的左区间包含数i - 1）并记录左区间A，同样地，我们在树中查找 j 的位置并拆分，记录右区间B，将B旋转到根，再将A旋转为B的左儿子，则A的右子树就是待操作的区间，对其进行标记即可。

下面贴出我的代码，尽可能使注释详细

 //date 20140119
 #include <cstdio>
 #include <cstring>

 inline int getint() //读入优化
 {
     int ans (); char w = getchar();
     while('' > w || '' < w)w = getchar();
     while('' <= w && w <= '')
     {
         ans = ans *  + w - '';
         w = getchar();
     }
     return ans;
 }

 inline int min(int a, int b){return a < b ? a : b;}
 inline int max(int a, int b){return a > b ? a : b;}

 int n, m;
 struct SPlay
 {
     struct node
     {
         int l, r, rev, revit, size; // l、r为区间左右端点，rev标记以当前节点为根的整棵子树是否被翻转，revit标记当前节点所代表的区间是否被翻转
         node *s[], *p;
         int sum(){return r - l + ;}
         int getlr(){return p->s[] == this;}
         node(int ll, int rr){l = ll; r = rr; s[] = s[] = p = ; rev = revit = ; size = sum();}
         node *link(int w, node *p){s[w] = p; if(p)p->p = this; return this;}
         void update(){size = (s[] ? s[]->size : ) + (s[] ? s[]->size : ) + sum();}
         void pushdown()//旋转标记下放
         {
             if(rev)
             {
                 node *q = s[]; s[] = s[]; s[] = q;
                 if(s[])s[]->rev ^= ;
                 if(s[])s[]->rev ^= ;
                 revit ^= ;
                 rev = ;
             }
         }
     }*root;

     void rot(node *p)
     {
         node *q = p->p->p;
         p->getlr() ? p->link(, p->p->link(, p->s[])) : p->link(, p->p->link(, p->s[]));
         p->p->update();
         if(q)q->link(q->s[] == p->p, p);else{root = p; p->p = ;}
     }

     void splay(node *p, node *tar)
     {
         while(p->p != tar && p->p->p != tar)
             p->getlr() == p->p->getlr() ? (rot(p->p), rot(p)) : (rot(p), rot(p));
         if(p->p != tar)rot(p);
         p->update();
     }

     void preset(int l, int r){root = new node(l, r);}
     //以上是伸展树的基本操作，如有不熟悉可以参照我博客之前一篇介绍伸展树的文章
     int findKth(int k)//寻找当前序列的第k个数所在的区间，并将其旋转到根，返回值pos是指需要将找到的区间从该区间的第pos个数拆成两个区间
     {
         node *p = root;
         p->pushdown();
         while(!(((p->s[] ? p->s[]->size : ) < k) && ((p->s[] ? p->s[]->size : ) + p->sum() >= k)))//如果没有找到则继续找
         {
             if((p->s[] ? p->s[]->size : ) >= k){p = p->s[]; p->pushdown();}
             else{k -= (p->s[] ? p->s[]->size : ) + p->sum(); p = p->s[]; p->pushdown();}
         }
         k -= (p->s[] ? p->s[]->size : );//记录k在该区间中的实际位置，以便拆点
         splay(p, );
         return k;
     }

     void divide(node *p, int pos)//将节点p拆成两个节点，使拆解后的左区间包含恰好pos个数
     {
         p->pushdown();
         if(p->sum() == pos)return;//如果不需要拆，则不拆
         node *q1, *q2;
         if(p->revit)
         {
             q1 = new node(p->r - pos + , p->r); q1->revit = ;
             q2 = new node(p->l, p->r - pos); q2->revit = ;
         }
         else
         {
             q1 = new node(p->l, p->l + pos - );
             q2 = new node(p->l + pos, p->r);
         }
         q1->link(, q2->link(, p->s[]));
         q1->link(, p->s[]);
         q2->update();
         q1->update();
         if(!p->p)root = q1;
         else p->p->link(p->getlr(), q1);
         delete p;
     }

     node *succ()//寻找当前根节点的后继，属于基础操作
     {
         root->pushdown();
         node *q = root->s[];
         q->pushdown();
         while(q->s[]){q = q->s[]; q->pushdown();}
         splay(q, );
         return q;
     }
     void deal(int a, int b)//翻转区间[a,b]
     {
         int i = findKth(a - );//找到当前区间的前驱
         divide(root, i);
         node *p = root;
         int j = findKth(b);//找到当前区间的后继
         divide(root, j);
         node *q = succ();
         splay(p, q);
         p->s[]->rev ^= ;//进行标记
         p->s[]->pushdown();
     }

     void print(node *p)//以下是一个中根便利进行输出
     {
         p->pushdown();
         if(p->s[])print(p->s[]);
         if(p->revit)for(int i = min(p->r, n); i >= max(, p->l); --i)printf("%d ", i);
         else for(int i = max(, p->l); i <= min(p->r, n); ++i)printf("%d ", i);
         if(p->s[])print(p->s[]);
     }

     void print()
     {
         print(root);
         printf("\n");
     }
 }S;

 int main()
 {
     n = getint(); m = getint();
     S.preset(, n + );//0和n + 1是哨兵节点，防止越界

     int x, y;
     for(int i = ; i <= m; ++i)
     {
         x = getint(); y = getint();
         S.deal(x + , y + );//由于0的存在，第x个数实际上是第x + 1个数
     }
     S.print();
     return ;
 }

小注：理解算法之后这道题就是锻炼编程能力了，希望能给在这道题卡住的同学们一点帮助吧