POJ 3580 SuperMemo （splay tree）

SuperMemo

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 6841		Accepted: 2268
Case Time Limit: 2000MS

Description

Your friend, Jackson is invited to a TV show called SuperMemo in which the participant is told to play a memorizing game. At first, the host tells the participant a sequence of numbers, {A₁, A₂, ... A_n}. Then the host performs a series of operations and queries on the sequence which consists:

1. ADD x y D: Add D to each number in sub-sequence {A_x ... A_y}. For example, performing "ADD 2 4 1" on {1, 2, 3, 4, 5} results in {1, 3, 4, 5, 5}
2. REVERSE x y: reverse the sub-sequence {A_x ... A_y}. For example, performing "REVERSE 2 4" on {1, 2, 3, 4, 5} results in {1, 4, 3, 2, 5}
3. REVOLVE x y T: rotate sub-sequence {A_x ... A_y} T times. For example, performing "REVOLVE 2 4 2" on {1, 2, 3, 4, 5} results in {1, 3, 4, 2, 5}
4. INSERT x P: insert P after A_x. For example, performing "INSERT 2 4" on {1, 2, 3, 4, 5} results in {1, 2, 4, 3, 4, 5}
5. DELETE x: delete A_x. For example, performing "DELETE 2" on {1, 2, 3, 4, 5} results in {1, 3, 4, 5}
6. MIN x y: query the participant what is the minimum number in sub-sequence {A_x ... A_y}. For example, the correct answer to "MIN 2 4" on {1, 2, 3, 4, 5} is 2

To make the show more interesting, the participant is granted a chance to turn to someone else that means when Jackson feels difficult in answering a query he may call you for help. You task is to watch the TV show and write a program giving the correct answer to each query in order to assist Jackson whenever he calls.

Input

The first line contains n (n ≤ 100000).

The following n lines describe the sequence.

Then follows M (M ≤ 100000), the numbers of operations and queries.

The following M lines describe the operations and queries.

Output

For each "MIN" query, output the correct answer.

Sample Input

5
1
2
3
4
5
2
ADD 2 4 1
MIN 4 5

Sample Output

5

Source

POJ Founder Monthly Contest – 2008.04.13, Yao Jinyu

 /* ***********************************************
 Author        :kuangbin
 Created Time  :2013/8/28 19:39:45
 File Name     :F:\2013ACM练习\专题学习\splay_tree_2\POJ3580.cpp
 ************************************************ */

 #include <stdio.h>
 #include <string.h>
 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <queue>
 #include <set>
 #include <map>
 #include <string>
 #include <math.h>
 #include <stdlib.h>
 #include <time.h>
 using namespace std;
 /*
  * 给定一个数列:a1,a2,.... an
  * 进行以下6种操作：
  * ADD x y D : 给第x个数到第y个数加D
  * REVERSE x y : 反转[x,y]
  * REVOVLE x y T : 对[x,y]区间的数循环右移T次
  *     (先把T对长度取模，然后相当于把[y-T+1,y]放到[x,y-T] 的前面)
  * INSERT x P  : 在第x个数后面插入P
  * DELETE x : 删除第x个数
  * MIN x y  : 查询[x,y]之间的最小的数
  */
 #define Key_value ch[ch[root][1]][0]
 const int MAXN = ;
 const int INF = 0x3f3f3f3f;
 int pre[MAXN],ch[MAXN][],root,tot1,size[MAXN];
 int key[MAXN],rev[MAXN],m[MAXN],add[MAXN];
 int s[MAXN],tot2;
 int a[MAXN];
 int n;
 void NewNode(int &r,int father,int k)
 {
     if(tot2) r = s[tot2--];
     else r = ++tot1;
     pre[r] = father;
     ch[r][] = ch[r][] = ;
     key[r] = k;
     m[r] = k;
     rev[r] = add[r] = ;
     size[r] = ;
 }
 void Update_Rev(int r)
 {
     if(!r)return;
     swap(ch[r][],ch[r][]);
     rev[r] ^= ;
 }
 void Update_Add(int r,int D)
 {
     if(!r)return;
     m[r] += D;
     key[r] += D;
     add[r] += D;
 }
 void push_up(int r)
 {
     size[r] = size[ch[r][]] + size[ch[r][]] + ;
     m[r] = min(key[r],min(m[ch[r][]],m[ch[r][]]));
 }
 void push_down(int r)
 {
     if(rev[r])
     {
         Update_Rev(ch[r][]);
         Update_Rev(ch[r][]);
         rev[r] = ;
     }
     if(add[r])
     {
         Update_Add(ch[r][],add[r]);
         Update_Add(ch[r][],add[r]);
         add[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()
 {
     root = tot1 = tot2 = ;
     ch[root][] = ch[root][] = pre[root] = ;
     rev[root] = add[root] = ;
     m[root] = INF;
     size[root] = ;
     NewNode(root,,-);
     NewNode(ch[root][],root,-);
     for(int i = ;i < n;i++)
         scanf("%d",&a[i]);
     Build(Key_value,,n-,ch[root][]);
     push_up(ch[root][]);
     push_up(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
         {
             push_down(pre[pre[r]]);
             push_down(pre[r]);
             push_down(r);
             int y = pre[r];
             int kind = ch[pre[y]][]==y;
             if(ch[y][kind] == r)
             {
                 Rotate(r,!kind);
                 Rotate(r,kind);
             }
             else
             {
                 Rotate(y,kind);
                 Rotate(r,kind);
             }
         }
     }
     push_up(r);
     if(goal == ) root = r;
 }

 int Get_kth(int r,int k)
 {
     push_down(r);
     int t = size[ch[r][]] + ;
     if(t == k) return r;
     if(t > k) return Get_kth(ch[r][],k);
     else return Get_kth(ch[r][],k-t);
 }

 void ADD(int x,int y,int D)
 {
     Splay(Get_kth(root,x),);
     Splay(Get_kth(root,y+),root);
     Update_Add(Key_value,D);
     push_up(ch[root][]);
     push_up(root);
 }
 void Reverse(int x,int y)
 {
     Splay(Get_kth(root,x),);
     Splay(Get_kth(root,y+),root);
     Update_Rev(Key_value);
     push_up(ch[root][]);
     push_up(root);
 }
 void REVOLVE(int x,int y,int T)
 {
     int len = y - x + ;
     T = ( T%len + len )%len;
     Splay(Get_kth(root,y-T+),);
     Splay(Get_kth(root,y+),root);
     int tmp = Key_value;
     Key_value = ;
     push_up(ch[root][]);
     push_up(root);
     Splay(Get_kth(root,x),);
     Splay(Get_kth(root,x+),root);
     Key_value = tmp;
     pre[tmp] = ch[root][];
     push_up(ch[root][]);
     push_up(root);
 }
 void INSERT(int x,int P)
 {
     Splay(Get_kth(root,x+),);
     Splay(Get_kth(root,x+),root);
     NewNode(Key_value,ch[root][],P);
     push_up(ch[root][]);
     push_up(root);
 }
 void erase(int r)
 {
     if(!r)return;
     s[++tot2] = r;
     erase(ch[r][]);
     erase(ch[r][]);
 }
 void DELETE(int x)
 {
     Splay(Get_kth(root,x),);
     Splay(Get_kth(root,x+),root);
     erase(Key_value);
     pre[Key_value] = ;
     Key_value = ;
     push_up(ch[root][]);
     push_up(root);
 }
 int MIN(int x,int y)
 {
     Splay(Get_kth(root,x),);
     Splay(Get_kth(root,y+),root);
     return m[Key_value];
 }
 int main()
 {
     //freopen("in.txt","r",stdin);
     //freopen("out.txt","w",stdout);
     while(scanf("%d",&n) == )
     {
         Init();
         int x,y,z;
         char op[];
         int q;
         scanf("%d",&q);
         while(q--)
         {
             scanf("%s",op);
             if(strcmp(op,"ADD") == )
             {
                 scanf("%d%d%d",&x,&y,&z);
                 ADD(x,y,z);
             }
             else if(strcmp(op,"REVERSE") == )
             {
                 scanf("%d%d",&x,&y);
                 Reverse(x,y);
             }
             else if(strcmp(op,"REVOLVE") == )
             {
                 scanf("%d%d%d",&x,&y,&z);
                 REVOLVE(x,y,z);
             }
             else if(strcmp(op,"INSERT") == )
             {
                 scanf("%d%d",&x,&y);
                 INSERT(x,y);
             }
             else if(strcmp(op,"DELETE") == )
             {
                 scanf("%d",&x);
                 DELETE(x);
             }
             else if(strcmp(op,"MIN") == )
             {
                 scanf("%d%d",&x,&y);
                 printf("%d\n",MIN(x,y));
             }
         }
     }
     return ;
 }