POJ3580---SuperMemo （Splay）

各种操作，区间更新，求最值、翻转、插入、删除、当然是Splay这种神器了。

主要是 revolve这个操作，其实也就是3个区间翻转放到一块，

比如 REVOLVE x y T，T %= （y-x+1）; 其实就是 先把 x y区间翻转，然后把  x x + c - 1区间和 x+ c  y区间分别翻转。

代码：

 #include <set>
 #include <map>
 #include <cmath>
 #include <ctime>
 #include <queue>
 #include <stack>
 #include <cstdio>
 #include <string>
 #include <vector>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 typedef unsigned long long ull;
 typedef long long ll;
 const int inf = 0x3f3f3f3f;
 const double eps = 1e-;
 const int maxn = 1e5+;
 int siz[maxn],minv[maxn],rev[maxn],addv[maxn],key[maxn];
 int ch[maxn][],a[maxn],pre[maxn],s[maxn];
 int n,tot1,tot2,root;
 void NewNode(int &r,int father,int k)
 {
     if (tot2)
         r = s[tot2--];
     else
         r = ++tot1;
     pre[r] = father;
     key[r] = k;
     siz[r] = ;
     minv[r] = k;
     ch[r][] = ch[r][] = ;
 }
 void update_Rev(int r)
 {
     if (!r)
         return ;
     swap(ch[r][],ch[r][]);
     rev[r] ^= ;
 }
 void push_up(int r)
 {
     siz[r] = siz[ch[r][]] + siz[ch[r][]] + ;
     minv[r] = min(key[r],min(minv[ch[r][]],minv[ch[r][]]));
 }
 void update_add(int r,int val)
 {
     if (!r)
         return ;
     key[r] += val;
     addv[r] += val;
     minv[r] += val;
 }
 void push_down(int r)
 {
     if (rev[r])
     {
         update_Rev(ch[r][]);
         update_Rev(ch[r][]);
         rev[r] = ;
     }
     if (addv[r])
     {
         update_add(ch[r][],addv[r]);
         update_add(ch[r][],addv[r]);
         addv[r] = ;
     }
 }

 void build(int &x,int l,int r,int father)
 {
     if (l > r)
         return;
     int mid = (l + r) >> ;
     NewNode(x,father,a[mid]);
     build(ch[x][],l,mid-,x);
     build(ch[x][],mid+,r,x);
     push_up(x);
 }
 void init()
 {
     tot1 = root = tot2 = ;
     for (int i = ; i <= n; i++)
         scanf ("%d",a+i);
     minv[root] = inf;
     NewNode(root,,-);
     NewNode(ch[root][],root,-);
     build(ch[ch[root][]][],,n,ch[root][]);
     push_up(root);
     push_up(ch[root][]);
 }
 void Rotate(int x,int kind)
 {
     int y = pre[x];
     push_down(y);
     push_down(x);
     ch[y][!kind] = ch[x][kind];
     pre[ch[x][kind]] = y;
     if (pre[y])
         ch[pre[y]][ch[pre[y]][] == y] = x;
     pre[x] = pre[y];
     ch[x][kind] = y;
     pre[y] = x;
     push_up(y);
 }
 void Splay(int r,int goal)
 {
     push_down(r);
     while (pre[r] != goal)
     {
         if (pre[pre[r]] == goal)
         {
             push_down(pre[r]);
             push_down(r);
             Rotate(r,ch[pre[r]][] == r);
         }
         else
         {
             int y = pre[r];
             push_down(pre[y]);
             push_down(y);
             push_down(r);
             int kind = (ch[pre[y]][] == y);
             if (ch[y][kind] == r)
             {
                 Rotate(y,!kind);
                 Rotate(r,!kind);
             }
             else
             {
                 Rotate(r,kind);
                 Rotate(r,!kind);
             }
         }
     }
     push_up(r);
     if (goal == )
         root = r;
 }
 int Get_kth(int r,int k)
 {
     push_down(r);
     int t = siz[ch[r][]] + ;
     if (t == k)
         return r;
     else if (t <= k)
         return Get_kth(ch[r][],k-t);
     else
         return Get_kth(ch[r][],k);
 }
 void eraser(int r)
 {
     if (!r)
         return;
     s[++tot2] = r;
     eraser(ch[r][]);
     eraser(ch[r][]);
 }
 void Delete(int x)
 {
     Splay(Get_kth(root,x),);
     Splay(Get_kth(root,x+),root);
     eraser(ch[ch[root][]][]);
     pre[ch[ch[root][]][]] = ;
     ch[ch[root][]][] = ;
     push_up(ch[root][]);
     push_up(root);
 }
 void Insert(int x,int val)
 {
     Splay(Get_kth(root,x+),);
     Splay(Get_kth(root,x+),root);
     NewNode(ch[ch[root][]][],ch[root][],val);
     push_up(ch[root][]);
     push_up(root);
 }
 void ADD(int u,int v,int val)
 {
     Splay(Get_kth(root,u),);
     Splay(Get_kth(root,v+),root);
     update_add(ch[ch[root][]][],val);
     push_up(ch[root][]);
     push_up(root);
 }
 int query(int ua,int ub)
 {
     Splay(Get_kth(root,ua),);
     Splay(Get_kth(root,ub+),root);
     return minv[ch[ch[root][]][]];
 }
 void Reverse (int u,int v)
 {
     Splay (Get_kth(root,u),);
     Splay (Get_kth(root,v+),root);
     update_Rev (ch[ch[root][]][]);
     push_up (ch[root][]);
     push_up (root);
 }
 void revolve(int u,int v,int c)
 {
     int len = (v - u + );
     c  %= len;
     if (!c)
         return;
     Reverse(u,v);
     Reverse(u,u+c-);
     Reverse(u+c,v);
 }
 int main(void)
 {
     #ifndef ONLINE_JUDGE
         freopen("in.txt","r",stdin);
     #endif
     while (~scanf ("%d",&n))
     {
         init();
         int m;
         scanf ("%d",&m);
         for (int i = ; i < m; i++)
         {
             char op[];
             int u,v,c;
             scanf ("%s",op);
             if (strcmp(op,"ADD") == )
             {
                 scanf ("%d%d%d",&u,&v,&c);
                 ADD(u,v,c);
             }
             if (strcmp(op,"REVERSE") == )
             {
                 scanf ("%d%d",&u,&v);
                 Reverse(u,v);
             }
             if (strcmp(op,"REVOLVE") == )
             {
                 scanf ("%d%d%d",&u,&v,&c);
                 revolve(u,v,c);
             }
             if (strcmp(op,"INSERT") == )
             {
                 scanf ("%d%d",&u,&v);
                 Insert(u,v);
             }
             if (strcmp(op,"DELETE") == )
             {
                 scanf ("%d",&u);
                 Delete(u);
             }
             if (strcmp(op,"MIN") == )
             {
                 scanf ("%d%d",&u,&v);
                 printf("%d\n",query(u,v));
             }
         }
     }
     return ;
 }