【伸展树】伸展树复习

HNOI2002 营业额统计

/*******************************\ * @prob: HNOI2002 营业额统计    * * @auth: Wang Junji           * * @stat: Accepted.            * * @date: June. 28th, 2012     * * @memo: 伸展树                *\*******************************/#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <string>const int maxN = 200010, INF = 0x3f3f3f3f;class SplayTree{private:    struct Node    {        int key, cnt, sz; Node *F, *lc, *rc; Node() {} /* Node */        Node(int key): key(key), cnt(1), sz(1) {} /* Node */    } NIL[maxN], *T, *tot;    Node* NewNode(int key)    {        Node* tmp = new (tot++) Node(key);        tmp -> F = tmp -> lc = tmp -> rc = NIL;        return tmp;    } /* NewNode */    void update(Node* T) {T -> sz = T -> lc -> sz + T -> rc -> sz + T -> cnt; return;} /* update */    void Zig(Node* T)    {        Node *P = T -> F, *tmp = T -> rc;        if (P == this -> T) this -> T = T;        else (P -> F -> lc == P) ? (P -> F -> lc = T) : (P -> F -> rc = T);        T -> F = P -> F; P -> F = T; P -> lc = tmp;        tmp -> F = T -> rc = P; update(P); return;    } /* Zig */    void Zag(Node* T)    {        Node *P = T -> F, *tmp = T -> lc;        if (P == this -> T) this -> T = T;        else (P -> F -> lc == P) ? (P -> F -> lc = T) : (P -> F -> rc = T);        T -> F = P -> F; P -> F = T; P -> rc = tmp;        tmp -> F = T -> lc = P; update(P); return;    } /* Zag */    void Splay(Node*& T, Node* t)    {        while (t != T)        {            Node* P = t -> F;            if (P == T) P -> lc == t ? Zig(t) : Zag(t);            else            {                if (P -> F -> lc == P) P -> lc == t ? Zig(P) : Zag(t), Zig(t);                else                   P -> lc == t ? Zig(t) : Zag(P), Zag(t);            } /* else */        } /* while */        update(t); return;    } /* Splay */    void Find(int v)    {        for (Node* t = T; t != NIL;)        {            if (v == t -> key ||                 (v < t -> key && t -> lc == NIL) ||                (v > t -> key && t -> rc == NIL))            {Splay(T, t); break;} /* if */            t = v < t -> key ? t -> lc : t -> rc;        } /* for */        return;    } /* Find */public:    SplayTree()    {        tot = NIL; NewNode(0); NewNode(~INF); NewNode(INF);        NIL -> sz = NIL -> cnt = 0;        NIL[1].rc = NIL + 2, NIL[1].sz = 2;        NIL[2].F  = NIL + 1; T = NIL + 1;    } /* SplayTree */    void Ins(int v)    {        Node *t = T;        while (t != NIL)        {            ++t -> sz;            if (v == t -> key) {++t -> cnt; break;}            if (v < t -> key && t -> lc == NIL)            {                Node* p = NewNode(v);                t -> lc = p, p -> F = t;                t = p; break;            } /* if */            if (v > t -> key && t -> rc == NIL)            {                Node* p = NewNode(v);                t -> rc = p, p -> F = t;                t = p; break;            } /* if */            t = v < t -> key ? t -> lc : t -> rc;        } /* while */        if (t != NIL) Splay(T, t);        return;    } /* Ins */    int pred(int v)    {        Find(v); if (T -> cnt > 1) return v;        Node* t = T -> lc;        for (; t -> rc != NIL; t = t -> rc);        return t -> key;    } /* pred */    int succ(int v)    {        Find(v); if (T -> cnt > 1) return v;        Node* t = T -> rc;        for (; t -> lc != NIL; t = t -> lc);        return t -> key;    } /* succ */} Tr; int n, x;int main(){    freopen("Revenue.in" , "r", stdin );    freopen("Revenue.out", "w", stdout);    scanf("%d%d", &n, &x); Tr.Ins(x); int ans = x;    while (--n)    {        x = 0; scanf("%d", &x); Tr.Ins(x);        //输入数据中漏了两个数，所以读入前x要赋为0。        int pred = Tr.pred(x), succ = Tr.succ(x);        ans += std::min(x - pred, succ - x);    } /* while */    printf("%d\n", ans); return 0;} /* main *//*伸展树模板题，不多说。*/

hdu1890 Robotic Sort

/********************************\ * @prob: hdu1890 Robotic Sort  * * @auth: Wang Junji            * * @stat: Accepted.             * * @date: June. 30th, 2012      * * @memo: 伸展树                 *\********************************/#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <string>const int maxN = 100010;class SplayTree{private:    struct Node    {        int key, sz; bool rev; Node *lc, *rc, *F; Node() {} /* Node */        Node(int key): key(key), sz(1), rev(false) {} /* Node */    } NIL[maxN], *ele[maxN], *T, *tot; int cur;    Node* NewNode(int key)    {        Node* T = new (tot++) Node(key);        T -> lc = T -> rc = T -> F = NIL;        return T;    } /* NewNode */    void pushdown(Node* T)    {        if (T -> rev)        {            std::swap(T -> lc, T -> rc);            if (T -> lc != NIL) T -> lc -> rev ^= 1;            if (T -> rc != NIL) T -> rc -> rev ^= 1;            T -> rev = false;        } /* if */        return;    } /* pushdown */    void update(Node* T) {T -> sz = T -> lc -> sz + T -> rc -> sz + 1;} /* update */    void Zig(Node* T)    {        Node *P = T -> F, *tmp = T -> rc;        pushdown(T -> lc); pushdown(T -> rc); pushdown(P -> rc);        if (P == this -> T) this -> T = T;        else P -> F -> lc == P ? (P -> F -> lc = T) : (P -> F -> rc = T);        T -> F = P -> F; P -> F = T; P -> lc = tmp;        tmp -> F = T -> rc = P; update(P); return;    } /* Zig */    void Zag(Node* T)    {        Node *P = T -> F, *tmp = T -> lc;        pushdown(T -> lc); pushdown(T -> rc); pushdown(P -> lc);        if (P == this -> T) this -> T = T;        else P -> F -> lc == P ? (P -> F -> lc = T) : (P -> F -> rc = T);        T -> F = P -> F; P -> F = T; P -> rc = tmp;        tmp -> F = T -> lc = P; update(P); return;    } /* Zag */    void Splay(Node*& T, Node* t)    {        for (pushdown(t); t != T;)        {            Node* P = t -> F;            if (P == T) P -> lc == t ? Zig(t) : Zag(t);            else            {                if (P -> F -> lc == P) P -> lc == t ? Zig(P) : Zag(t), Zig(t);                else                   P -> lc == t ? Zig(t) : Zag(P), Zag(t);            } /* else */        } /* for */        update(t); return;    } /* Splay */    void K_th(Node*& T, int k)    {        for (Node* t = T; pushdown(t), t != NIL && k > 0;)        {            if (k == t -> lc -> sz + 1) {Splay(T, t); return;}            if (k <= t -> lc -> sz) t = t -> lc;            else k -= t -> lc -> sz + 1, t = t -> rc;        } /* for */        return;    } /* K_th */    void modify(Node* t)    {        if (t -> F != NIL) modify(t -> F);        pushdown(t);        return;    } /* modify */    static bool cmp(const Node* const& a, const Node* const& b) {return a -> key < b -> key;} /* cmp */public:    SplayTree() {init();} /* SplayTree */    void init(const int* __fir = NULL, const int *__la = NULL)    {        tot = NIL; T = NewNode(0); NIL[0].sz = 0; cur = 0;        if (__fir == __la) return;        const int* fir = __fir; Node *p, *q;        ele[0] = T = p = NewNode(*fir);        while (++fir != __la)        {            ele[fir - __fir] = q = NewNode(*fir);            p -> rc = q, q -> F = p, p = q;        } /* while */        std::stable_sort(ele, ele + (__la - __fir), cmp);        //这里一定要用stable_sort，否则会打乱相同大小元素的顺序。        Splay(T, p); return;    } /* init */    int count()    {        Node* t = ele[cur++];        modify(t); Splay(T, t);        int res = T -> lc -> sz;        if (T -> lc == NIL) T = T -> rc, T -> F = NIL;        else        {            T -> lc -> rev ^= 1;            K_th(T -> lc, T -> lc -> sz);            T -> lc -> rc = T -> rc;            T -> rc -> F = T -> lc;            T = T -> lc;            T -> F = NIL;            update(T);        } /* else */        return res;    } /* count */} Tr; int a[maxN], n;int main(){    freopen("Sort.in" , "r", stdin );    freopen("Sort.out", "w", stdout);    while (~scanf("%d", &n) && n)    {        for (int* i = a; i != a + n;) scanf("%d", i++);        if (n == 1) {printf("1\n"); continue;}        Tr.init(a, a + n);        for (int i = 0; i + 1 < n; ++i)            printf("%d ", i + Tr.count() + 1);        printf("%d\n", n + Tr.count());    } /* while */    return 0;} /* main *//*由于每次翻转都必然有一个元素（未排好序元素中的最小）达到指定位置，题目意思也就是求每次翻转的终点。将还需排序的结点放在一颗伸展树中，每次将里面最小的元素提到根，然后倒转左子树，删掉根（根结点已经排好序，所以删掉根，同时由于对根结点的排序，根结点左边的所有数都会被翻转一次），于是翻转的终点就是已经排好序的元素个数加上左子树的大小再加一。*/

hdu3487 Play with Chain

/***********************************\ * @prob: hdu3487 Play with Chain  * * @auth: Wang Junji               * * @stat: Accepted.                * * @date: June. 29th, 2012         * * @memo: 伸展树                    *\***********************************/#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <string>const int maxN = 3000010;class SplayTree{private:    struct Node    {        int key, sz; bool rev; Node *lc, *rc, *F; Node() {} /* Node */        Node(int key): key(key), sz(1), rev(false) {} /* Node */    } NIL[maxN], *T, *tot;    static int num[maxN], *fir, *la;    Node* NewNode(int v)    {        Node* T = new (tot++) Node(v);        T -> lc = T -> rc = T -> F = NIL;        return T;    } /* NewNode */    void update(Node* T) {T -> sz = T -> lc -> sz + T -> rc -> sz + 1; return;} /* update */    void pushdown(Node* T)    {        if (T -> rev)        {            std::swap(T -> lc, T -> rc);            if (T -> lc != NIL) T -> lc -> rev ^= 1;            if (T -> rc != NIL) T -> rc -> rev ^= 1;            T -> rev = false;        } /* if */        return;    } /* pushdown */    void Zig(Node* T)    {        Node *P = T -> F, *tmp = T -> rc;        pushdown(T -> lc); pushdown(T -> rc); pushdown(P -> rc);        if (P == this -> T) this -> T = T;        else (P -> F -> lc == P) ? (P -> F -> lc = T) : (P -> F -> rc = T);        T -> F = P -> F; P -> F = T; P -> lc = tmp;        tmp -> F = T -> rc = P; update(P); return;    } /* Zig */    void Zag(Node* T)    {        Node *P = T -> F, *tmp = T -> lc;        pushdown(T -> lc); pushdown(T -> rc); pushdown(P -> lc);        if (P == this -> T) this -> T = T;        else (P -> F -> lc == P) ? (P -> F -> lc = T) : (P -> F -> rc = T);        T -> F = P -> F; P -> F = T; P -> rc = tmp;        tmp -> F = T -> lc = P; update(P); return;    } /* Zag */    void Splay(Node*& T, Node* t)    {        for (pushdown(t); t != T;)        {            Node* P = t -> F;            if (P == T) (P -> lc == t) ? Zig(t) : Zag(t);            else            {                if (P -> F -> lc == P) (P -> lc == t) ? Zig(P) : Zag(t), Zig(t);                else                   (P -> lc == t) ? Zig(t) : Zag(P), Zag(t);            } /* else */        } /* for */        update(t); return;    } /* Splay */    void K_th(Node*& T, int k)    {        for (Node* t = T; t != NIL && k > 0;)        {            pushdown(t);            if (k == t -> lc -> sz + 1) {Splay(T, t); return;}            if (k <= t -> lc -> sz) t = t -> lc;            else k -= t -> lc -> sz + 1, t = t -> rc;        } /* for */        return;    } /* K_th */    void print(Node* T)    {        if (T == NIL) return; pushdown(T);        if (T -> lc != NIL) print(T -> lc);        if (T -> key) *la++ = T -> key;        if (T -> rc != NIL) print(T -> rc);        return;    } /* print */public:    SplayTree() {init();} /* SplayTree */    void init(int fir = 0, int la = 0)    {        tot = NIL; NewNode(0); NewNode(0); NewNode(0);        NIL[0].sz = 0;        NIL[1].sz = 2; NIL[1].rc = NIL + 2;        NIL[2].F = NIL + 1;        T = NIL + 1;        if (fir == la) return;        Node* p = NewNode(fir++);        T -> rc -> lc = p; p -> F = T -> rc;        while (fir != la)        {            Node* q = NewNode(fir++);            p -> rc = q; q -> F = p; p = q;        } /* while */        Splay(T, p); return;    } /* init */    void cut(int L, int R, int pos)    {        K_th(T, L); K_th(T -> rc, R - L + 2);        Node* p = T -> rc -> lc;        T -> rc -> lc = p -> F = NIL;        update(T -> rc); update(T);        K_th(T, pos + 1); K_th(T -> rc, 1);        T -> rc -> lc = p, p -> F = T -> rc;        update(T -> rc); update(T); return;    } /* cut */    void Flip(int L, int R)    {        K_th(T, L); K_th(T -> rc, R - L + 2);        T -> rc -> lc -> rev ^= 1;        Splay(T, T -> rc -> lc); return;    } /* Flip */    void println()    {        fir = la = num; print(T);        if (fir == la) {puts(""); return;} /* if */        while (fir != la - 1) printf("%d ", *fir++);        printf("%d\n", *fir++); return;    } /* println */} Tr; int n, m, x, y, p; char str[20];int SplayTree::num[maxN], *SplayTree::fir, *SplayTree::la;int main(){    freopen("Chain.in" , "r", stdin );    freopen("Chain.out", "w", stdout);    while (~scanf("%d%d", &n, &m) && ~n && ~m)    {        Tr.init(1, n + 1);        while (m--) switch (scanf("%s%d%d", str, &x, &y), str[0])        {        case 'C': scanf("%d", &p); Tr.cut(x, y, p); break;        case 'F': Tr.Flip(x, y); break;        } /* switch */        Tr.println();    } /* while */    return 0;} /* main *//*伸展树的模板题，不再多说。注意输出时在行末不能多一个空格。*/

spoj4487 Can you answer these queries VI

/****************************************************\ * @prob: spoj4487 Can you answer these queries VI  * * @auth: Wang Junji        * @stat: Accepted.      * * @date: June. 29th, 2012  * @memo: 伸展树          *\****************************************************/#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <string>using std::min; using std::max;const int maxN = 200010, INF = 0x07070707;inline int& gmax(int& a, const int& b) {return a > b ? a : (a = b);} /* gmax */inline int& gmin(int& a, const int& b) {return a < b ? a : (a = b);} /* gmin */class SplayTree{private:    struct Node    {        int key, sum, mls, mrs, Max, sz; Node *lc, *rc, *F; Node() {} /* Node */        Node(int key): key(key), sum(key), mls(key), mrs(key), Max(key), sz(1) {} /* Node */    } NIL[maxN], *T, *tot;    Node* NewNode(int key)    {        Node* T = new (tot++) Node(key);        T -> lc = T -> rc = T -> F = NIL;        return T;    } /* NewNode */    void update(Node* T)    {        T -> sum = T -> lc -> sum + T -> rc -> sum + T -> key;        T -> sz  = T -> lc -> sz  + T -> rc -> sz  + 1;         T -> mls = T -> lc -> mls;        gmax(T -> mls, T -> lc -> sum + T -> key);        gmax(T -> mls, T -> lc -> sum + T -> key + T -> rc -> mls);        T -> mrs = T -> rc -> mrs;        gmax(T -> mrs, T -> rc -> sum + T -> key);        gmax(T -> mrs, T -> rc -> sum + T -> key + T -> lc -> mrs);        T -> Max = T -> key;        gmax(T -> Max, max(T -> lc -> Max, T -> rc -> Max));        gmax(T -> Max, max(T -> mls, T -> mrs));        gmax(T -> Max, max(T -> lc -> mrs, T -> rc -> mls) + T -> key);        gmax(T -> Max, T -> lc -> mrs + T -> key + T -> rc -> mls);        return;    } /* update */    void Zig(Node* T)    {        Node *P = T -> F, *tmp = T -> rc;        if (P == this -> T) this -> T = T;        else P -> F -> lc == P ? (P -> F -> lc = T) : (P -> F -> rc = T);        T -> F = P -> F; P -> F = T; P -> lc = tmp;        tmp -> F = T -> rc = P; update(P); return;    } /* Zig */    void Zag(Node* T)    {        Node *P = T -> F, *tmp = T -> lc;        if (P == this -> T) this -> T = T;        else P -> F -> lc == P ? (P -> F -> lc = T) : (P -> F -> rc = T);        T -> F = P -> F; P -> F = T; P -> rc = tmp;        tmp -> F = T -> lc = P; update(P); return;    } /* Zag */    void Splay(Node*& T, Node* t)    {        while (T != t)        {            Node* P = t -> F;            if (P == T) P -> lc == t ? Zig(t) : Zag(t);            else            {                if (P -> F -> lc == P) P -> lc == t ? Zig(P) : Zag(t), Zig(t);                else                   P -> lc == t ? Zig(t) : Zag(P), Zag(t);            } /* else */        } /* while */        update(t); return;    } /* Splay */    void K_th(Node*& T, int k)    {        for (Node* t = T; t != NIL && k > 0;)        {            if (k == t -> lc -> sz + 1) {Splay(T, t); return;}            if (k <= t -> lc -> sz) t = t -> lc;            else k -= t -> lc -> sz + 1, t = t -> rc;        } /* for */        return;    } /* K_th */public:    SplayTree()    {        tot = NIL; NewNode(~INF); NewNode(~INF); NewNode(~INF);        NIL[0].sz = 0; NIL[0].sum = NIL[0].key = 0;        NIL[1].sz = 2; NIL[1].rc = NIL + 2; NIL[1].sum = NIL[1].key = 0;        NIL[2].F = T = NIL + 1; NIL[2].sum = NIL[2].key = 0;    } /* SplayTree */    void Ins(int pos, int v)    {        K_th(T, pos); K_th(T -> rc, 1);        Node* p = NewNode(v);        T -> rc -> lc = p, p -> F = T -> rc;        update(T -> rc); update(T); return;    } /* Ins */    void Del(int pos)    {        K_th(T, pos); K_th(T -> rc, 2);        T -> rc -> lc = NIL;        update(T -> rc); update(T); return;    } /* Del */    void Replace(int pos, int v) {K_th(T, pos + 1); T -> key = v; update(T); return;} /* Replace */    int query(int L, int R)    {        K_th(T, L); K_th(T -> rc, R - L + 2);        return T -> rc -> lc -> Max;    } /* query */} Tr; int n, m, x, y; char str[10];int main(){    freopen("query4.in" , "r", stdin );    freopen("query4.out", "w", stdout);    scanf("%d", &n);    for (int i = 0; i < n; ++i) scanf("%d", &x), Tr.Ins(i + 1, x);    scanf("%d", &m);    while (m--) switch (scanf("%s%d", str, &x), str[0])    {    case 'D': Tr.Del(x); break;    case 'I': scanf("%d", &y); Tr.Ins    (x, y); break;    case 'R': scanf("%d", &y); Tr.Replace(x, y); break;    case 'Q': scanf("%d", &y); printf("%d\n", Tr.query(x, y)); break;    } /* switch */    return 0;} /* main *//*伸展树模板题，不再多说。*/

NOI2005 维护数列

/****************************\ * @prob: NOI2005 维护数列   * * @auth: Wang Junji        * * @stat: Accepted.         * * @date: June. 29th, 2012  * * @memo: 伸展树             *\****************************/#include <cstdio>#include <cstdlib>#include <algorithm>#include <cstring>#include <string>using std::min; using std::max;const int maxN = 300010, INF = 0x07070707;inline int& gmax(int& a, const int& b) {return a > b ? a : (a = b);} /* gmax */inline int& gmin(int& a, const int& b) {return a < b ? a : (a = b);} /* gmin */class SplayTree{private:    struct Node    {        int key, sum, mls, mrs, Max, sz; bool rev, sm;        Node *lc, *rc, *F; Node() {} /* Node */        Node(int key): key(key), sum(key), mls(key),            mrs(key), Max(key), sz(1), rev(false), sm(false) {} /* Node */    } *NIL, *T;    Node* NewNode(int v)    {        Node* T = new Node(v);        T -> lc = T -> rc = T -> F = NIL;        return T;    } /* NewNode */    void release(Node*& T)    {        if (T -> lc != NIL) release(T -> lc);        if (T -> rc != NIL) release(T -> rc);        if (T != NIL) delete T;        T = NIL; return;    } /* release */    void pushdown(Node* T)    {        Node *&lc = T -> lc, *&rc = T -> rc;        if (T -> rev)        {            std::swap(lc, rc);            std::swap(T -> mls, T -> mrs); //            if (lc != NIL) lc -> rev ^= 1;            if (rc != NIL) rc -> rev ^= 1;            T -> rev = false;        } /* if */        if (T -> sm)        {            if (lc != NIL) lc -> sm = true, lc -> key = T -> key;            if (rc != NIL) rc -> sm = true, rc -> key = T -> key;            T -> sum = T -> sz * T -> key; //            T -> mls = T -> mrs = T -> Max = max(T -> sum, T -> key); //            T -> sm = false;        } /* if */        return;    } /* pushdown */    void update(Node* T)    {        Node *&lc = T -> lc, *&rc = T -> rc;        T -> sz  = lc -> sz  + rc -> sz  + 1;        T -> sum = lc -> sum + rc -> sum + T -> key;        T -> mls = lc -> mls;        gmax(T -> mls, lc -> sum + T -> key);        gmax(T -> mls, lc -> sum + T -> key + rc -> mls);        T -> mrs = rc -> mrs;        gmax(T -> mrs, rc -> sum + T -> key);        gmax(T -> mrs, rc -> sum + T -> key + lc -> mrs);        T -> Max = T -> key;        gmax(T -> Max, max(lc -> Max, rc -> Max));        gmax(T -> Max, max(T -> mls, T -> mrs));        gmax(T -> Max, max(lc -> mrs, rc -> mls) + T -> key);        gmax(T -> Max, lc -> mrs + T -> key + rc -> mls);        return;    } /* update */    void Zig(Node* T)    {        Node *P = T -> F, *tmp = T -> rc;        pushdown(T -> lc); pushdown(T -> rc); pushdown(P -> rc);        if (P == this -> T) this -> T = T;        else P -> F -> lc == P ? (P -> F -> lc = T) : (P -> F -> rc = T);        T -> F = P -> F; P -> F = T; P -> lc = tmp;        tmp -> F = T -> rc = P; update(P); return;    } /* Zig */    void Zag(Node* T)    {        Node *P = T -> F, *tmp = T -> lc;        pushdown(T -> lc); pushdown(T -> rc); pushdown(P -> lc);        if (P == this -> T) this -> T = T;        else P -> F -> lc == P ? (P -> F -> lc = T) : (P -> F -> rc = T);        T -> F = P -> F; P -> F = T; P -> rc = tmp;        tmp -> F = T -> lc = P; update(P); return;    } /* Zag */    void Splay(Node*& T, Node* t)    {        for (pushdown(t); t != T;)        {            Node* P = t -> F;            if (P == T) P -> lc == t ? Zig(t) : Zag(t);            else            {                if (P -> F -> lc == P) P -> lc == t ? Zig(P) : Zag(t), Zig(t);                else                   P -> lc == t ? Zig(t) : Zag(P), Zag(t);            } /* else */        } /* for */        update(t); return;    } /* Splay */    void K_th(Node*& T, int k)    {        for (Node* t = T; pushdown(t), t != NIL && k > 0;)        {            if (k == t -> lc -> sz + 1) {Splay(T, t); return;}            if (k <= t -> lc -> sz) t = t -> lc;            else k -= t -> lc -> sz + 1, t = t -> rc;        } /* for */        return;    } /* K_th */public:    SplayTree()    {        NIL = NewNode(~INF); T = NewNode(~INF); T -> rc = NewNode(~INF);        NIL -> lc = NIL -> rc = NIL -> F = NIL;        NIL -> sz = 0; NIL -> key = NIL -> sum = 0; T -> sz = 2;        T -> rc -> F = T;    } /* SplayTree */    void Ins(int pos, int* fir, int* la)    {        if (fir == la) return;        K_th(T, pos + 1); K_th(T -> rc, 1);        Node* p = NewNode(*fir++);        T -> rc -> lc = p, p -> F = T -> rc;        while (fir != la)        {            Node* q = NewNode(*fir++);            p -> rc = q, q -> F = p, p = q;        } /* while */        Splay(T, p); return;    } /* Ins */    void Del(int pos, int num)    {        K_th(T, pos); K_th(T -> rc, num + 1);        release(T -> rc -> lc); Splay(T, T -> rc);        //update(T -> rc); update(T); return;    } /* Del */    void rev(int pos, int num)    {        K_th(T, pos); K_th(T -> rc, num + 1);        T -> rc -> lc -> rev ^= 1; Splay(T, T -> rc -> lc); //        //pushdown(T -> rc -> lc); return;    } /* rev */    void mksm(int pos, int num, int v)    {        K_th(T, pos); K_th(T -> rc, num + 1);        T -> rc -> lc -> key = v;        T -> rc -> lc -> sm = true; Splay(T, T -> rc -> lc); //        //pushdown(T -> rc -> lc); return;    } /* mksm */    int qsum(int pos, int num)    {        K_th(T, pos); K_th(T -> rc, num + 1);        return T -> rc -> lc -> sum;    } /* qsum */    int qmax() {return T -> Max;} /* qmax */} Tr; int a[maxN], n, m, x, y, p; char str[20];int main(){    freopen("sequence.in" , "r", stdin );    freopen("sequence.out", "w", stdout);    scanf("%d%d", &n, &m);    for (int* i = a; i != a + n;) scanf("%d", i++);    Tr.Ins(0, a, a + n);    while (m--)    {        scanf("%s", str);        if (!strcmp(str, "MAX-SUM")) printf("%d\n", Tr.qmax());        else        {            scanf("%d%d", &x, &y);            if      (!strcmp(str, "GET-SUM")) printf("%d\n", Tr.qsum(x, y));            else if (!strcmp(str, "DELETE" )) Tr.Del(x, y);            else if (!strcmp(str, "REVERSE")) Tr.rev(x, y);            else if (!strcmp(str, "INSERT" ))            {                for (int* i = a; i != a + y;) scanf("%d", i++);                Tr.Ins(x, a, a + y);            } /* if */            else scanf("%d", &p), Tr.mksm(x, y, p);        } /* else */    } /* while */    return 0;} /* main *//*要注意两个虚拟结点的sum值不能设为零。*/