Splay模板

//poj3580
//#pragma comment(linker,"/STACK:102400000,102400000")
#include <cstdio>
#include <set>
#include <map>
#include <ctime>
#include <cctype>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <assert.h>
#include <algorithm>
#include <iostream>
#include <climits>
#include <queue>
#include <vector>

#define dte(x) cout << #x << " = " << x << endl;
#define scaf2(x,y) scaf(x);scaf(y);
#define mkp make_pair
  
using namespace std;
template<typename T>inline void scaf(T&v)
{
    char ch = getchar();
    for(; ch < '0' || ch > '9'; ch = getchar());
    for(v = 0; ch >= '0' && ch <= '9'; ch = getchar()) v = (v << 1) +(v << 3) + ch - '0';
}
typedef long long LL;
typedef unsigned long long ULL;
typedef pair <int, int> PII;
const int maxN = 2e5 + 10;
const LL mod = 1e9 + 7;
const double eps = 1e-9;
const LL oo = ~ 0U >> 2;

int inn[maxN];

struct SplayTree
{
    static const int smaxN = 4e5 + 10;
    #define keyNode chird[chird[root][1]][0]
    int item[smaxN];
    int parent[smaxN];
    int sz[smaxN];
    int chird[smaxN][2];
    
    int root, vtot;
    
    SplayTree()
    {
        root = vtot = 0;
        item[0] = -1;
        parent[0] = sz[0] = chird[0][0] = chird[0][1] = 0;
    }
    
    void Rotate(const int& x, const int& lr)
    {//lr - > 0: leftRotate 1: rightRotate
        int y = parent[x];
        pushDown(y); pushDown(x);
        chird[y][! lr] = chird[x][lr];
        if (chird[x][lr]) parent[chird[x][lr]] = y;
        parent[x] = parent[y];
        if (parent[y])
        {
            if (chird[parent[y]][0] == y) chird[parent[y]][0] = x;
            else chird[parent[y]][1] = x;
        }
        chird[x][lr] = y; parent[y] = x;
        pushUp(y);
    }
    
    void Splay(int x, const int& target)
    {//Splay x to target't chird -- target must be x's ancestor
        for (pushDown(x); parent[x] != target;)
        {
            if (parent[parent[x]] == target)/*x's father's father is target -> rotate x to x's father*/
            {
                if (chird[parent[x]][0] == x) Rotate(x, 1);
                else Rotate(x, 0);
            }else
            {
                int y = parent[x], z = parent[parent[x]];
                if (chird[z][0] == y)/*y is z's lson*/
                {
                    if (chird[y][0] == x) Rotate(y, 1), Rotate(x, 1);//yi zi xing
                    else Rotate(x, 0), Rotate(x, 1);//zhi zi xing
                }else
                {
                    if (chird[y][0] == x) Rotate(x, 1), Rotate(x, 0);//zhi
                    else Rotate(y, 0), Rotate(x, 0);//yi
                }
            }
        }
        pushUp(x);
        if (!target) root = x;
    }
    
    int Search(const int& target)
    {
        int x = root;
        while (x)
        {
            if (item[x] == target) break;
            if (item[x] > target) x = chird[x][0];
            else x = chird[x][1];
        }
        if (x) Splay(x, 0);
        return x;
    }
    
    void Insert(const int& target, const int& _id)
    {
//        if (Search(target)) return;//exist?
        int x = root, y = 0, lr;
        while (x)
        {
            y = x; ++ sz[y];
            if (item[x] > target) x = chird[x][0];
            else x = chird[x][1];
        }
        if (item[y] > target) lr = 0;
        else lr = 1;
        sz[x = ++ vtot] = 1;
        parent[x] = y; chird[y][lr] = x;
        item[x] = target;
        chird[x][0] = chird[x][1] = 0;
        Splay(x, 0);
    }
    
    void Delete(const int& target)
    {
        int x = Search(target);
        if (!x) return;//no exist
        int lc = chird[x][0], rc = chird[x][1];
        sz[x] = parent[lc] = parent[rc] = chird[x][0] = chird[x][1] = 0;
        if (!lc) root = rc;
        else
        {
            for (pushDown(lc); chird[lc][1]; pushDown(lc)) lc = chird[lc][1];
            Splay(lc, 0);
            parent[rc] = lc;
            chird[lc][1] = rc;
            pushUp(root);
        }
    }
    
    int findParent(const int& target)
    {
        int x = root, ret = 0;
        while (x)
        {
            if (target <= item[x]) x = chird[x][0];
            else ret = x, x = chird[x][1];
        }
        if (ret) Splay(ret, 0);
        return ret;
    }
    
    int findSuccessor(const int& target)
    {
        int x = root, ret = 0;
        while (x)
        {
            if (target >= item[x]) x = chird[x][1];
            else ret = x, x = chird[x][0];
        }
        if (ret) Splay(ret, 0);
        return ret;
    }
    
    int findKth(int k, const int& target)
    {
        int x = root;
        while (x)
        {
            pushDown(x);
             int y = sz[chird[x][0]];
            if (y == k) break;
            if (y > k) x = chird[x][0];
            else x = chird[x][1], k -= y + 1;
        }
        if (x) Splay(x, target);
        return x;//item[x]???
    }
    
    void Treaval(const int& x, int& num)
    {
        if (x)
        {
            pushDown(x);
            Treaval(chird[x][0], num);
            printf("%d", item[x]);
            if (-- num) putchar(32);
            else putchar(10);
            Treaval(chird[x][1], num);
        }
    }
    
    void outPut(int n)
    {
        int m = n;
        findKth(0, 0);
        Treaval(root, m);
    }
    
    void newNode(int& x, const int& val, const int& father)
    {
        item[x = ++ vtot] = val; sz[x] = 1; parent[x] = father; 
        minVal[x] = val; rev[x] = false; addLazy[x] = 0;
        chird[x][0] = chird[x][1] = 0;
    }
    
    void buildSplay(int n)
    {
        root = vtot = 0;
        item[0] = 0; rev[0] = 0; addLazy[0] = 0; minVal[0] = oo;
        parent[0] = sz[0] = chird[0][0] = chird[0][1] = 0;
        newNode(root, oo, 0);//ex node?
        newNode(chird[root][1], oo, root);
        buildTree(keyNode, 1, n, chird[root][1]);
        pushUp(chird[root][1]);
        pushUp(root);
    }
    
    void buildTree(int& x, const int& l, const int& r, const int& father)
    {
        if (l > r) return;
        int mid = l + r >> 1;
        newNode(x, inn[mid], father);
        buildTree(chird[x][0], l, mid - 1, x);
        buildTree(chird[x][1], mid + 1, r, x);
        pushUp(x);
    }
    
    void pushUp(const int& x)
    {
        sz[x] = sz[chird[x][0]] + sz[chird[x][1]] + 1;
        minVal[x] = item[x];
        if (chird[x][0]) minVal[x] = min(minVal[x], minVal[chird[x][0]]);
        if (chird[x][1]) minVal[x] = min(minVal[x], minVal[chird[x][1]]);;
    }
    
    void pushDown(const int& x)
    {
        if (rev[x])
        {
            int lc = chird[x][0], rc = chird[x][1];
            swap(chird[x][0], chird[x][1]);
            if (lc) rev[lc] ^= 1;
            if (rc) rev[rc] ^= 1;
            rev[x] ^= 1;
        }
        if (addLazy[x])
        {
            if (chird[x][0])
            {
                item[chird[x][0]] += addLazy[x];
                minVal[chird[x][0]] += addLazy[x];
                addLazy[chird[x][0]] += addLazy[x];
            }
            if (chird[x][1])
            {
                item[chird[x][1]] += addLazy[x];
                minVal[chird[x][1]] += addLazy[x];
                addLazy[chird[x][1]] += addLazy[x];
            }
            addLazy[x] = 0;
        }
    }
    
    void add(const int& l, const int& r, const int& v)
    {
        findKth(l - 1, 0); findKth(r + 1, root);
        item[keyNode] += v;
        addLazy[keyNode] += v;
        minVal[keyNode] += v;
        Splay(keyNode, 0);
    }
    
    void insVal(const int& l, const int& v)
    {
        findKth(l, 0); findKth(l + 1, root);
        if (keyNode) while (1);
        newNode(keyNode, v, chird[root][1]);
        Splay(keyNode, 0);
    }
    
    void del(const int& target)
    {
        findKth(target, 0);
        pushDown(root);
        int x = root;
        int lc = chird[x][0], rc = chird[x][1];
        sz[x] = parent[lc] = parent[rc] = chird[x][0] = chird[x][1] = 0;
        if (!lc) root = rc;
        else
        {
            for (pushDown(lc); chird[lc][1]; pushDown(lc)) lc = chird[lc][1];
            Splay(lc, 0);
            parent[rc] = lc;
            chird[lc][1] = rc;
            pushUp(root);
        }
    }
    
    int getMin(const int& l, const int& r)
    {
        findKth(l - 1, 0); findKth(r + 1, root);
        return minVal[keyNode];
    }
    
    void Reverse(const int& l, const int& r)
    {
        findKth(l - 1, 0); findKth(r + 1, root);
        rev[keyNode] ^= 1;
        Splay(keyNode, 0);
    }
    
    void Revolve(const int& l, const int& r, const int& v)
    {
        int rr = r - v;
        int ll = rr + 1;
        findKth(ll - 1, 0); findKth(r + 1, root);
        int x = keyNode; keyNode = 0; parent[x] = 0;
        pushUp(chird[root][1]); pushUp(root);
        findKth(l - 1, 0); findKth(l, root);
        keyNode = x;
        parent[keyNode] = chird[root][1];
        pushUp(chird[root][1]); pushUp(root);
        Splay(keyNode, 0);
    }
    
    int minVal[smaxN];
    int addLazy[smaxN];
    bool rev[smaxN];
}spt;

int main()
{
//    freopen("ok.out", "w", stdout);
    int n, i, m;
    int l, r, v;
    char opt[10];
//    scaf(n);
    scanf("%d", &n);
    for (i = 1; i <= n; ++ i)
//        scaf(inn[i]);
        scanf("%d", &inn[i]);
    spt.buildSplay(n);
//    scaf(m);
    scanf("%d", &m);
    while (m --)
    {
        scanf("%s", opt);
//        printf("%s
", opt);
        if ('A' == opt[0])
        {
//            scaf2(l, r); scaf(v);
            scanf("%d%d%d", &l, &r, &v);
            spt.add(l, r, v);
        }else if ('I' == opt[0])
        {
//            scaf2(l, v);
            scanf("%d%d", &l, &v);
            spt.insVal(l, v);
        }else if ('D' == opt[0])
        {
//            scaf(v);
            scanf("%d", &v);
             spt.del(v);
//             spt.outPut(spt.sz[spt.root]);
        }else if ('M' == opt[0])
        {
//            scaf2(l, r);
            scanf("%d%d", &l, &r);
            printf("%d
", spt.getMin(l, r));
        }else if ('E' == opt[3])
        {
//            scaf2(l, r);
            scanf("%d%d", &l, &r);
            spt.Reverse(l, r);
//            spt.outPut(spt.sz[spt.root]);
        }else
        {
//            scaf2(l, r); scaf(v);
            scanf("%d%d%d", &l, &r, &v);
            int len = r - l + 1;
            v = (v % len + len) % len;
            if (v) spt.Revolve(l, r, v);
        }
        spt.findKth(0, 0);
//        spt.outPut(spt.sz[spt.root]);
//        printf("%d
", spt.sz[spt.root]);
    }
    return 0;
}