【伸展树】伸展树复习

最新推荐文章于 2020-07-20 22:59:03 发布
最新推荐文章于 2020-07-20 22:59:03 发布
阅读量2.7k 收藏
点赞数 1
分类专栏： OI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Whjpji/article/details/7705482
版权
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值不能设为零。

*/



Whjpji
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
void free(void *ptr)调用后ptr的值是什么
Vincent
01-19 3002
使用后该指针变量ptr一定要重新指向NULL，防止野指针出现，有效 规避误操作。比如如下：当然这是C版的；不全但是最后结果看截图。可以知道ptr指向还是原来的内存单元，只不过是该内存单元被标示可擦除了。 typedef struct data{ int year; char *name; }Data;Data *pd=malloc(sizeof(Data)); pd->nam
数据结构期末复习----伸展树
m0_48933755的博客
01-09 314
伸展树详解和功能解析 1.什么是伸展树： 从本质上来讲，伸展树是一棵排序二叉树，但是经常要做伸展操作。（这里的经常是真的经常，几乎每一次操作后面都跟着一个伸展操作，所以伸展树的其他基本操作都是基于伸展操作的） 2.伸展树的基本操作： 既然上面提到了伸展树的基本操作，那 伸展树都有哪些基本操作呢？ 伸展操作（Spaly）：伸展操作就是将某个节点调整到根。 插入操作（Insert）：向伸展树中插入新节点的操作。 删除操作（Delete）：删除伸展树中存在的元素。 tips:也有一些其他莫名奇妙的操作，比如输出
(void**)ptr操作的理解
织席贩履之辈
07-20 2268
首先来说，ptr是一个指针，首先看一个简单的 int* ptr; void* p1 = (void*)ptr; 表示把整型指针进行强制类型转换成空类型指针 void类型指针接受任何类型的指针变量复制，因为他仅仅接收的是变量的首地址。 float **ptr; int **p = (int **)ptr; // 指针的强制类型转换 指针的类型是指明指针向后偏移多少个字节。 ...
(void *)ptr 和 (*(void**))是否相同
ShawnWang1994的博客
06-29 4347
(void *)ptr 将变量ptr的值强制转换为 void（无类型）的指针 (*(void**))ptr 将变量ptr的值强制转换为 (void*)，即把一个指向（void类型指针）的指针，求他的值，结果相当于括号里面的（void类型指针） 这两个的效果是完全一样的，用前面那种就可以了 ...
关于void*类型的用法（目前自己所能想到的）
gukesdo的专栏
04-17 7707
    1.C++语言在对于void* 类型的使用很特别，因为void* 可以间接引用任何其他数据类型的指针，比如int*、float*甚至抽象数据类型的指针，而且可以从void* 强制转换为任何其他数据类型的指针，所以使用起来有时候会比较危险。如果开始将一个void*的指针间接引用一个float*的指针，然后将这个void*指针强制转化为一个int*类型的指针，编译器不会给出错误甚至警告，但是输出的数据却匪夷所思，如果再强制转换会float*则不会出现任何问题；      在后来发现，C++语言中（使用v
伸展树复习
weixin_30449453的博客
03-28 64
T1 郁闷的出纳员 一个数据结构，支持单点插入、删除几个不一定连续的点、查询k值操作 初做：2017.2.18 time：1268ms memory:3MB http://www.cnblogs.com/TheRoadToTheGold/p/6412790.html 现在：2017.3.28 time：570ms memory：3MB 初做时直接套模板，删除分5种情况，...
hdu 4699 Editor 伸展树 treap复习
Nicolas
01-29 1450
题意：对一个数列进行操作，光标位置后面插入一个权值为x的数，删除光标前的那个数，光标左移一位，光标右移一位，求1到k位置的最大的前缀和。。 注意这里的k是在光标之前的，由于这个条件，所以这题又简单的2个栈维护可以解，如果没有这个条件，那么就要用伸展树了。 之前写过这题题解，数组的splay和栈都写过 以前的链接 其它操作都没问题，这里主要讲讲 询问操作。 对于操作Q x：相
伸展树复习 (bzoj 1251 序列终结者)
whai的专栏
08-05 1993
本来要看LCT的，确发现自己弱得连splay都忘记了，复习一发，顺便重写一发 关键点： 1. 伸展树为左小右大的二叉树，所以旋转操作不会影响树的性质 2. 区间操作为： int u = select(L - 1), v = select(R + 1); splay(u, 0); splay(v, u); //通过旋转操作把询问的区间聚集到根的右子树的左子树下 因为伸展树为左小右大
伸展树 学习笔记
TungstenC
11-04 216
听说 lemon 不太资瓷指针和动态开内存，所以学了一下数组非递归版的伸展树，简单记一下。（没有仔细写，只是为了方便复习，所以并不是一篇入门教程） 以模版题 普通平衡树 为例。 维护信息： int rt,ch[maxn][2],fa[maxn],v[maxn],c[maxn],sz[maxn],tot=0; inline void mt(int x) {sz[x]=sz[ch[x][0]]+c[x...
人教版二年级下册语文总复习资料分类.doc
10-10
第三单元听写涵盖了海岛、伸展、建立、纱巾、环绕、围绕、胜利、隐约、节省、茂盛、春季、季节、停留、杏树、茂密、蜜蜂、山坡、搭桥、采摘、摘抄、图钉、沟通、能够、足够、龙虾、报恩、寿礼、长寿、松柏、活泼、...
说透一级指针和二级指以及(void**)&在双链表中的应用
编程的本质是数学问题
05-14 6012
void (*signal (int signo,void (*func) (int) )) (int)这一大堆看起来很难，其实仔细分析下不算很难搞。 首先要明白一件事：这里都是从最基本的语法展开的。 那么这里最基本的语法就是函数的声明：返回值 函数名（参数）。 先将这一大堆给看成void (f)(int)也就是将*signal (int signo,void (*func) (in
2024年公关服务行业分析报告.pptx
07-09
行业报告
惠州市建筑物矢量数据（Shp格式+带高度）.txt
最新发布
07-09
因文件较多，数据存放网盘，txt文件内包含下载链接及提取码，永久有效。失效会第一时间进行补充。
Matlab语言教程及案例
07-09
项目总结 本文详细介绍了Matlab的基础知识和一个完整的数据分析与可视化案例。内容包括： 1. **基本操作**：基本算术运算和矩阵操作。 2. **绘图**：二维和三维绘图。 3. **函数和脚本**：编写和运行Matlab函数和脚本。 4. **案例分析**：生成模拟数据，进行数据预处理、绘图和统计分析。 通过这个项目，读者可以掌握Matlab的基本使用方法，并了解如何在Matlab中进行数据分析和可视化。这对于初学者入门Matlab编程、提升数据处理和分析能力非常有帮助。希望本文能为读者提供有价值的参考，提升其Matlab编程和数据分析技能。
KB8825英文数据手册
07-09
三星KB8825英文数据手册
述职报告（08）PPT模板.pptx
07-09
述职报告（08）PPT模板.pptx
知识产权优势培育企业推荐表.docx
07-09
知识产权优势培育企业推荐表.docx
ACM 程序设计：伸展树-p1.pdf
06-18
"这篇文档是华南师范大学的ACM程序设计课程讲稿，主要讨论了伸展树（Splay Tree）的概念及其在ACM程序设计中的应用。内容包括二叉排序树的基本操作，如查找第k个最小元素的方法，以及算法的时间复杂度分析。此外，还...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值