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 = 200010;
const int INF = 0x3f3f3f3f;
int pre[MAXN],ch[MAXN][2],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][0] = ch[r][1] = 0;
    key[r] = k;
    m[r] = k;
    rev[r] = add[r] = 0;
    size[r] = 1;
}
void Update_Rev(int r)
{
    if(!r)return;
    swap(ch[r][0],ch[r][1]);
    rev[r] ^= 1;
}
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][0]] + size[ch[r][1]] + 1;
    m[r] = min(key[r],min(m[ch[r][0]],m[ch[r][1]]));
}
void push_down(int r)
{
    if(rev[r])
    {
        Update_Rev(ch[r][0]);
        Update_Rev(ch[r][1]);
        rev[r] = 0;
    }
    if(add[r])
    {
        Update_Add(ch[r][0],add[r]);
        Update_Add(ch[r][1],add[r]);
        add[r] = 0;
    }
}
void Build(int &x,int l,int r,int father)
{
    if(l > r)return;
    int mid = (l+ r)/2;
    NewNode(x,father,a[mid]);
    Build(ch[x][0],l,mid-1,x);
    Build(ch[x][1],mid+1,r,x);
    push_up(x);
}
void Init()
{
    root = tot1 = tot2 = 0;
    ch[root][0] = ch[root][1] = pre[root] = 0;
    rev[root] = add[root] = 0;
    m[root] = INF;
    size[root] = 0;
    NewNode(root,0,-1);
    NewNode(ch[root][1],root,-1);
    for(int i = 0;i < n;i++)
        scanf("%d",&a[i]);
    Build(Key_value,0,n-1,ch[root][1]);
    push_up(ch[root][1]);
    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]][1]==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]][0]==r);
        }
        else
        {
            push_down(pre[pre[r]]);
            push_down(pre[r]);
            push_down(r);
            int y = pre[r];
            int kind = ch[pre[y]][0]==y;
            if(ch[y][kind] == r)
            {
                Rotate(r,!kind);
                Rotate(r,kind);
            }
            else
            {
                Rotate(y,kind);
                Rotate(r,kind);
            }
        }
    }
    push_up(r);
    if(goal == 0) root = r;
}

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

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