POJ 3580 SuperMemo （Splay）

最新推荐文章于 2019-11-17 11:08:32 发布
最新推荐文章于 2019-11-17 11:08:32 发布
阅读量479 收藏
点赞数 2
分类专栏： POJ Splay伸展树 文章标签： Splay
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aozil_yang/article/details/78216883
版权

思路：

区间的一系列操作， 还有翻转什么的，显然Splay

主要说一下 那个循环右移的操作吧

次数先对总长度取模， 因为相当于有循环节。

然后  这个操作 相当于 把一个区间分成两个子区间， 把后面挪到前面。

假设两个区间是 [s1, e1]和 [s2, e2]

那么先把s2-1 转到根， e2+1 转到根的下面， 将e2转到e2+1的下面，将 e2+1的左子树 切下来。

这样就把后一个区间拿出来了，  同样的操作  将s1-1转到根， s1 转到根的下面， 插到 s1左子树即可。


#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;


const int maxn = 200000 + 10;
int n, m;
int num[maxn];
const int inf = 0x3f3f3f3f;
struct SplayTree{
    void Rotate(int x, int f){
        int y = pre[x], z = pre[y];
        pushdown(x);
        pushdown(y);
        ch[y][!f] = ch[x][f]; pre[ch[x][f] ] = y;
        ch[x][f] = y; pre[y] = x;
        pre[x] = z;
        if (pre[x]) ch[z][ch[z][1] == y ] = x;
        pushup(y);
    }
    void Splay(int x,int goal){

        pushdown(x);
        while(pre[x] != goal){
            if (pre[pre[x] ] == goal){
                Rotate(x, ch[pre[x] ][0] == x);

            }
            else {
                int y = pre[x], z = pre[y];
                int f = (ch[z][0] == y);
                if (ch[y][f] == x) Rotate(x, !f), Rotate(x, f);
                else Rotate(y, f), Rotate(x, f);
            }

        }
        pushup(x);
        if (goal == 0) root = x;
    }


    void RotateTo(int k,int goal){
        int x = root;
        pushdown(x);
        while(sz[ ch[x][0] ] != k){
            if (k < sz[ ch[x][0] ]){
                x = ch[x][0];
            }
            else {
                k -= (sz[ ch[x][0] ] + 1);
                x = ch[x][1];
            }
            pushdown(x);

        }
        Splay(x, goal);
    }
    void clear(){
        ch[0][0] = ch[0][1] = pre[0] = sz[0] = 0;
        top = 0;
        root = n = 0;
        val[0] = -inf;
        Min[0] = inf;
        rev[0] = 0;
        add[0] = 0;
        NewNode(root, -inf);
        NewNode(ch[root][1], inf);
        pre[n] = root;
        sz[root] = 2;
    }
    void NewNode(int& x,int c){
        if (top) x = pool[--top];
        else x = ++n;
        ch[x][0] = ch[x][1] = pre[x] = 0;
        sz[x] = 1;
        val[x] = Min[x] = c;
    }
    void pushup(int x){
        sz[x] = 1 + sz[ch[x][0] ] + sz[ch[x][1] ];
        Min[x] = min(val[x] , min(Min[ch[x][0] ] , Min[ch[x][1] ]));
    }
    void pushdown(int x){
        if (rev[x]){
            update_rev(ch[x][0]);
            update_rev(ch[x][1]);
            rev[x] = 0;
        }
        if (add[x]){
            update_add(ch[x][0], add[x]);
            update_add(ch[x][1], add[x]);
            add[x] = 0;
        }
    }
    void init(int pos, int tot){
        clear();
        cnt = tot;
        RotateTo(pos, 0);
        RotateTo(pos + 1, root);
        build(ch[ ch[root][1] ][0], 1, tot, ch[root][1]);
        pushup(ch[root][1]);
        pushup(root);
    }
    void build(int& x,int l,int r,int f){
        if (l > r) return ;
        int mid = (l + r) >> 1;
        NewNode(x, num[mid]);
        build(ch[x][0],l, mid-1, x);
        build(ch[x][1], mid+1, r, x);
        pre[x] = f;
        pushup(x);
    }


    void update_add(int x,int v){
        if (!x) return;
        val[x] += v;
        Min[x] += v;
        add[x] += v;
    }

    void update_rev(int x){
        if (!x) return;
        swap(ch[x][0], ch[x][1]);
        rev[x] ^= 1;
    }
    void ADD(int l,int r,int c){
        RotateTo(l - 1, 0);
        RotateTo(r + 1, root);
        int key = ch[ch[root][1] ][0];
        update_add(key, c);
        pushup(ch[root][1]);
        pushup(root);
    }
    int getmin(int l,int r){
        RotateTo(l-1,0);
        RotateTo(r+1,root);
        int key = ch[ch[root][1] ][0];
        return Min[key];
    }
    void reverse(int l, int r){
        RotateTo(l-1, 0);
        RotateTo(r + 1, root);
        int key = ch[ ch[root][1] ][0];
        update_rev(key);

    }


    void erase(int x){
        if (!x) return;
        pool[top++] = x;
        erase(ch[x][0]);
        erase(ch[x][1]);
    }

    void del(int x){
        RotateTo(x-1, 0);
        RotateTo(x+1, root);
        int key = ch[ ch[root][1] ][0];
        ch[ ch[root][1] ][0] = 0;
        cnt -= sz[key];
        erase(key);
        pushup(ch[root][1]);
        pushup(root);
    }


    void insert(int pos, int v){
        cnt++;
        RotateTo(pos, 0);
        RotateTo(pos + 1, root);
        num[1] = v;
        build(ch[ ch[root][1] ][0], 1, 1, ch[root][1]);
        pushup(ch[root][1]);
        pushup(root);
    }


    void revolve(int x, int y, int t){
        t %= (y-x+1);
        if (t < 0) t = y - x + 1 + t;
        if (t == 0) return;
        int s2 = y - t + 1, e2 = y;
        int s1 = x, e1 = s2 - 1;
        RotateTo(s2 - 1, 0);
        RotateTo(e2 + 1, root);
        int haha = ch[root][1];
        RotateTo(e2, haha);
        int key = ch[ ch[root][1] ][0];
        pre[key] = 0;
        ch[ch[root][1] ][0] = 0;
        pushup(ch[root][1]);
        pushup(root);
        RotateTo(s1 - 1, 0);
        RotateTo(s1, root);
        ch[ch[root][1] ][0] = key;
        pre[key] = ch[root][1];
        pushup(ch[root][1]);
        pushup(root);
    }
    int root, n, cnt, ct, top;
    int ch[maxn][2];
    int pre[maxn];
    int sz[maxn];
    int val[maxn];
    int Min[maxn];
    int add[maxn];
    int pool[maxn];
    int rev[maxn];

}spt;

int main(){
    int n;
    scanf("%d",&n);

    for (int i = 1; i <= n; ++i){
        scanf("%d", &num[i]);
    }
    int q;
    spt.init(0, n);
    scanf("%d", &q);
    char op[10];
    while(q--){
        scanf("%s", op);
        if (op[0] == 'A'){
            int x, y, d;
            scanf("%d %d %d",&x, &y, &d);
            spt.ADD(x, y, d);
        }
        else if (op[0] == 'R'){
            if (op[3] == 'E'){
                int x, y;
                scanf("%d %d",&x, &y);
                spt.reverse(x, y);
            }
            else {
                int x, y, t;
                scanf("%d %d %d", &x, &y, &t);
                spt.revolve(x, y, t);

            }


        }
        else if (op[0] == 'I'){
            int x, p;
            scanf("%d %d",&x, &p);
            spt.insert(x, p);
        }
        else if (op[0] == 'D'){
            int x;
            scanf("%d", &x);
            spt.del(x);

        }
        else {
            int x, y;
            scanf("%d %d", &x, &y);
            printf("%d\n", spt.getmin(x, y));
        }
    }
    return 0;
}

SuperMemo
Time Limit: 5000MS Memory Limit: 65536K
Total Submissions: 16777 Accepted: 5288
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, {A1, A2, ... An}. 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 {Ax ... Ay}. 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 {Ax ... Ay}. 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 {Ax ... Ay} 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 Ax. For example, performing "INSERT 2 4" on {1, 2, 3, 4, 5} results in {1, 2, 4, 3, 4, 5}
  5. DELETE x: delete Ax. 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 {Ax ... Ay}. 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

[Submit]   [Go Back]   [Status]   [Discuss]


aozil_yang
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pku 3580 splay
12-13
POJ 3580代码 Splay tree实现
POJ 3580 SuperMemo（区间树）
Quack
11-22 552
唯一一个要说的就是REVOLVE操作。别的在笔记上有。 可以发现REVOLVE就是把一段区间砍下来然后接在一个点后面。 那么先把这个区间砍下来（rotateto（l-1,0）rotateto（r+1,root）），然后pushup，然后找到那个点（rotateto（x,0）rotateto（x+1,root）），然后插入回去。最后pushup。#include<iostream> #includ
poj3580:SuperMemo（块状链表/Splay）
DZYO的博客
07-17 348
传送门 题意： 题目要求实现一种数据结构，支持6种操作： add x,y D：第x个数到第y个数之间的数每个加D； reverse x y：第x个数到第y个数之间全部数翻转； revolve x y T：第x个数到第y个数之间的数，向后循环流动T次，即后面T个数变成这段子序列的最前面T个，前面的被挤到后面。 Insert x P：在第x个数后面插入一个数P。 Delete x：删除第x个数
poj 3580
Dash
04-17 660
平衡树裸题，这是新的平衡树模板。 平衡树，区间加值，区间翻转，区间查询最小值。 我还是太年轻了。。。too young too simple。。。
poj3580 SuperMemo splay --- 从入门到入土
forOnward的博客
11-17 298
(太可怕了，我只是一个刚学懂splay的蒟蒻） poj地址：http://poj.org/problem?id=3580 AcWing地址：https://www.acwing.com/problem/content/268/ 题意： 给你一个数列 A1~An 有几个操作： 输入格式 第一行包含一个整数 n。 接下来 n 行给出了序列中的数。 接下来一行包含一个整数 ...
(POJ) 3580 SuperMemo
一只不争气的蒸汽机的博客
05-06 289
传送门 一道很全的splay模板题，自己搞了半天都不对，只能考别人的代码感受一下AC的味道，真香。 #include<cstdio> #include<iostream> #include<algorithm> #include<string> #include<cstring> #include<queue> #inc...
Super-Memo-poj3580.zip_memo
09-24
An solution of a problem using Splay Trees
poj.rar_poj
09-20
POJ 上的近100道水题，基本涵盖了所有基本算法和数据结构，全部AC
POJ.rar_poj
09-19
poj nwpu 2013 年才语言答案，不是全部，仅供参考
POJ 3580 —— Splay模板
XMzhou的专栏
10-02 753
SuperMemo Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 7161   Accepted: 2368 Case Time Limit: 2000MS Description Your friend, Jackson is invited to a
poj3580(splay 毒瘤题）
allia990718的博客
06-22 343
3: Lydsy1895 SuperMemo Time Limit: 10 SecMemory Limit: 64 MBSubmit: 15Solved: 11[Submit][Status][Web Board] Description 给出一个初始序列fA1;A2;:::Ang，要求你编写程序支持如下操作： 1. ADDxyD：给子序列fAx:::Ayg的每个元素都...
伸展树（区间加值，反转，循环移动，插入，删除区间，求区间最小值）poj3580
龙崎的专栏
11-26 756
Language: Default SuperMemo Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 10056   Accepted: 3234 Case Time Limit: 2000MS Description Your frie
POJ3580 SuperMemo
weixin_30530939的博客
03-11 182
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, {A1, A2, ... A...
BZOJ 1895 & POJ 3580 supermemo （splay）
K键盘里的青春K
09-08 1469
SuperMemo Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 16524   Accepted: 5214 Case Time Limit: 2000MS Description Your friend, Jackson is invited t
POJ 3580 较复杂的Splay区间维护题解题报告
Free keyboard 跳动的键盘
08-13 792
一、浅谈Splay：在做完这道题后，我对Splay又有了一些新的理解，先简单的介绍一下： 1. 在完成最普通的插入和查询时，Splay的时间复杂度可能会高于Treap等平衡树，但是只用它来维护点的信息是大材小用了的。 2. Splay的核心操作就是伸展（将某个点旋转到某个点的下方），它不仅维护了一颗平衡树，还支持许多十分“高级”的功能（例如区间维护和动态树上的Preferred Path维护等），
poj 3580 伸展树重口味题
努力奋斗才能梦想成真
09-30 1712
http://poj.org/problem?id=3580 注意，inf设的不要太小，还有对于题目输入数据的各种处理（可能有非法数据），要注意判断，具体见代码 #include #include #include using namespace std; const int inf = ~0u>>2; #define L ch[x][0] #define R ch[x][1] #d
POJ 3580
tmeteorj的专栏
08-19 1590
题意：给一个数组，有6种操作： add  x y d ： [x,y]中所有数加d reverse x y: [x,y]区间翻转 revolve x y t: [x,y]循环右移t位，t可取任意整数 insert  x v: 在第x个位置插入一个值为v的数 delete x : 删除第x个数 min x y : 求区间[x,y]的最小值 题解：典型splay，通过旋转
splay__poj3580
zz_ylolita
04-04 761
这真是很让人难过的一道题。。。。。但是我要硬着头皮写完splay TwT题目要求实现一种数据结构，支持6种操作： add x,y D：第x个数到第y个数之间的数每个加D； reverse x y：第x个数到第y个数之间全部数翻转； revolve x y T：第x个数到第y个数之间的数，向后循环流动T次，即后面T个数变成这段子序列的最前面T个，前面的被挤到后面。 Insert x P：在第x
POJ 3580 FHQ_Treap平衡树
maze_illusion的博客
08-02 350
题目链接 题意： 给一个长度为n的数组，初始为a1,...,an 需要维护以下操作： ADD l r x：给区间[l,r]上的所有元素+x REVERSE l r：反转区间[l,r]（比如：[1,2,3]反转后变成[3,2,1]） REVOLVE l r x：将区间[l,r]向前循环右移x位（比如：[1,2,3]循环右移2位变成[2,3,1]） INSERT P x：在位置P后插入一...
poj Divisibility
最新发布
09-12
POJ Divisibility是一个编程题，要求编写一个程序来确定一系列整数是否可被K整除。输入文件的第一行包含两个整数N和K，用一个空格分隔。第二行包含一系列N个整数，以空格分隔。每个整数的绝对值不大于10000。在输出...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值