poj3580 splay树 REVOVLE循环

最新推荐文章于 2017-11-03 16:55:16 发布
最新推荐文章于 2017-11-03 16:55:16 发布
阅读量611 收藏
点赞数
分类专栏： 数据结构 文章标签： splay
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fun_Zero/article/details/50707166
版权

SuperMemo
Time Limit: 5000MS Memory Limit: 65536K
Total Submissions: 12795 Accepted: 3989
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


/*
poj3580 splay树 REVOVLE循环
给定一个数列: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] 的前面，T可能出现负数或者特别大)
INSERT x P  : 在第x个数后面插入P
DELETE x : 删除第x个数
 MIN x y  : 查询[x,y]之间的最小的数

像min，add是参照rev，size来写。然后就只有第三个操作可以一开始想不到，其它大致就是各种基本操作的组合了
最开始写错del导致TLE几次

hhh-2016-02-21 03:06:02
*/

#include <functional>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <map>
#include <cmath>
using namespace std;
typedef long long ll;
typedef long  double ld;
#define key_value ch[ch[root][1]][0]
const int maxn = 200010;

int ch[maxn][2];
int pre[maxn],siz[maxn],num[maxn];
int rev[maxn],key[maxn];
int add[maxn];
int Min[maxn],a[maxn];
int tot;
int root;
void push_up(int r)
{
    int lson = ch[r][0],rson = ch[r][1];
    siz[r] = siz[lson] + siz[rson] + 1;
    Min[r] = min(key[r],min(Min[lson],Min[rson]));
}

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

void update_rev(int r)
{
    if(!r)return ;
    swap(ch[r][0],ch[r][1]);
    rev[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 NewNode(int &r,int far,int k)
{
    r = ++tot;      //不能为0
    pre[r] = far;
    ch[r][0] = ch[r][1] = 0;
    siz[r] = 1;
    Min[r] = k;
    key[r] = k;
    rev[r] = 0;
    add[r] = 0;
}


void rotat(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 build(int &x,int l,int r,int far)
{
    if(l > r) return ;
    int mid = (l+r) >>1;
    NewNode(x,far,a[mid]);
    build(ch[x][0],l,mid-1,x);
    build(ch[x][1],mid+1,r,x);
    push_up(x);
}

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);
            rotat(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)
            {
                rotat(r,!kind);
                rotat(r,kind);
            }
            else
            {
                rotat(y,kind);
                rotat(r,kind);
            }
        }
    }
    push_up(r);
    if(goal == 0)
        root = r;
}


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

int get_next(int r)
{
    push_down(r);
    if(ch[r][1] == 0)return -1;
    r = ch[r][1];
    while(ch[r][0])
    {
        r = ch[r][0];
        push_down(r);
    }
    return r;
}

void Reverse(int l,int r)
{
    splay(get_kth(root,l),0);
    splay(get_kth(root,r+2),root);
    update_rev(key_value);
    push_up(ch[root][1]);
    push_up(root);
}

void Add(int l,int r,int val)
{
    splay(get_kth(root,l),0);
    splay(get_kth(root,r+2),root);
    update_add(key_value,val);
    push_up(ch[root][1]);
    push_up(root);
}

void ini(int n)
{
    tot = root = 0;
    ch[root][0] = ch[root][1] = pre[root] = siz[root] = num[root] = 0;
    Min[root] = 0x3f3f3f3f;
    rev[root] = add[root] = 0;
    NewNode(root,0,-1);
    NewNode(ch[root][1],root,-1);
    for(int i=1; i <= n; i++)
    {
        scanf("%d",&a[i]);
    }
    build(key_value,1,n,ch[root][1]);

    push_up(ch[root][1]);
    push_up(root);
}

int get_min(int r)
{
    push_down(r);
    while(ch[r][0])
    {
        r = ch[r][0];
        push_down(r);
    }
    return r;
}

void Delete(int r)
{
    splay(get_kth(root,r+1),0);
    if(ch[root][0] == 0 || ch[root][1] == 0)
    {
        root = ch[root][0] + ch[root][1];
        pre[root] = 0;
        return;
    }
    int k = get_min(ch[root][1]);
    splay(k,root);
    ch[ch[root][1]][0] = ch[root][0];
    root = ch[root][1];
    pre[ch[root][0]] = root;
    pre[root] = 0;
    push_up(root);
}

void Insert(int x,int y)
{
    splay(get_kth(root,x+1),0);
    splay(get_kth(root,x+2),root);
    NewNode(key_value,ch[root][1],y);
    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);
    push_up(ch[root][1]);
    push_up(root);
    return Min[key_value];
}

void Revovle(int x,int y,int T)
{
    splay(get_kth(root,y-T+1),0);
    splay(get_kth(root,y+2),root);
    int tmp = key_value;
    //pre[key_value] = 0;
    key_value = 0;
    push_up(ch[root][1]);
    push_up(root);

    splay(get_kth(root,x),0);
    splay(get_kth(root,x+1),root);
    key_value = tmp;
    pre[key_value] = ch[root][1];
    push_up(ch[root][1]);
    push_up(root);
}

int main()
{
    int n,p;
    while(scanf("%d",&n) != EOF)
    {
        ini(n);
        scanf("%d",&p);
        char opr[20];
        int x,y,z;
        while(p--)
        {
            scanf("%s",opr);
            if(strcmp(opr,"ADD") == 0)
            {
                scanf("%d%d%d",&x,&y,&z);
                Add(x,y,z);
            }
            else if(strcmp(opr,"INSERT") == 0)
            {
                scanf("%d%d",&x,&y);
                Insert(x,y);
            }
            else if(strcmp(opr,"DELETE") == 0)
            {
                scanf("%d",&x);
                Delete(x);
            }
            else if(strcmp(opr,"MIN") == 0)
            {
                scanf("%d%d",&x,&y);
                printf("%d\n",MIN(x,y));
//                for(int i =1;i <= 5;i++)
//                    printf("%d\n",Min[i]);
            }
            else if(strcmp(opr,"REVERSE") == 0)
            {
                scanf("%d%d",&x,&y);
                Reverse(x,y);
            }
            else if(strcmp(opr,"REVOLVE") == 0)
            {
                scanf("%d%d%d",&x,&y,&z);
                int t = (y-x+1);
                z = (z%t+t)%t;
                Revovle(x,y,z);
            }
        }
    }
    return 0;
}



Tyuio28
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Splay树题解1
08-03
题目POJ3580是一个很好的例子，展示了Splay树如何处理多种操作，包括ADD、REVERSE、REVOLVE、INSERT、DELETE和MIN。HDOJ1754和HDOJ3487进一步说明了Splay树在处理区间修改操作和序列重组操作时的灵活性。 在处理大...
pku 3580 splay
12-13
POJ 3580代码 Splay tree实现
poj 3580 SuperMemo splay树模板题
sepNINE的专栏
04-24 1206
splay树 模板题
POJ 3580 Splay
u013268685的专栏(有一种幸福叫AC，有一种期待叫AK)
12-01 1263
G - SuperMemo Time Limit:5000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit Status Practice POJ 3580 Appoint description:  System Crawler  (2014-11-27) Descripti
POJ 3580 SuperMemo Splay
世界
09-22 1473
题目大意：维护一个序列，提供一些操作： 1.将一个区间加上一个值 2.翻转一个区间 3.将一个区间内的数字旋转T次(每次旋转区间内每个元素向右移一位，最右一个移动到最左面去) 4.在一个元素后面插入一个数 5.删除某个元素 6.查询区间最小值 写过BZOJ那几道Splay之后这题就变得非常水了。。。只是有几个要点需要注意： 1.操作3的T可能大于区间长度 还可能是负的 所以一定要取
Splay伸展树学习小记 Poj 3580 SuperMemo
whyorwhnt的专栏
08-27 1433
伸展树看了几天了，总算是摸着点方向，只能说这真的是神一样的数据结构，各种延迟标记…… 参考了很多大牛的博客，代码的基本写法从网上挑了一种比较好理解的开始模仿。 这里有一个模板和对一道题的分析，一开始我模仿的就是这个，最后发现指针还是有点不习惯……最后我会贴出用这个模板解这题的代码。 这个模板是少数这道题可以跑进1s内的，不过利用数组建树那部分似乎有bug： Splay Tree 标签_51
poj3580 SuperMemo
AaronPolaris
12-04 2309
又是一道Splay...
splay__poj3580
zz_ylolita
04-04 775
这真是很让人难过的一道题。。。。。但是我要硬着头皮写完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
BZOJ 1895 & POJ 3580 supermemo （splay）
K键盘里的青春K
09-08 1486
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. SuperMemo
热门推荐
Felix-Lee的博客
11-03 1万+
POJ 3580. SuperMemo DescriptionInputThe first line contains n (n ≤ 100000).The following n lines describe the sequence.Then follows M (M ≤ 100000), the numbers of operations and q
POJ3580 SuperMemo(Splay的区间操作)
geng4512的专栏
11-22 1538
传送门 第一次写Splay的区间操作，调了5+小时…… **Splay区间操作的核心就是区间的提取 例如：要提取[5, 12] 就要把4 Splay到根，把13 Splay到4的右儿子，那么13的左儿子就是[5, 12]的所有信息。**代码：#include<cstdio> #define MAXN 200005 int tmp; inline void Swap(int &a, int &b
poj 3580 伸展树重口味题
努力奋斗才能梦想成真
09-30 1750
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
Super-Memo-poj3580.zip_memo
09-24
但是，根据提供的信息，我们可以推测这个压缩包的内容主要围绕着Splay Tree的理论、实现以及如何应用于POJ3580问题的解决方案。对于想要学习Splay Tree或者解决类似问题的人来说，这是一个宝贵的资源。
POJ3277.rar_3277 poj_poj3277_多个面积_线段树
09-24
标题中的“POJ3277.rar_3277 poj_poj3277_多个面积_线段树”是指一个与编程竞赛相关的压缩文件，特别提到了POJ（Problemset Online Judge）的第3277号问题。POJ是一个著名的在线编程竞赛平台，参与者需要解决各种...
hdu5558 后缀数组
阳光下的泡沫
04-06 1260
Alice's Classified Message Time Limit: 16000/8000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 308    Accepted Submission(s): 118 Problem Description
2015 多校联赛 ——HDU5350（huffman）
阳光下的泡沫
08-04 1200
Problem Description MZL is a mysterious mathematician, and he proposed a mysterious function at his young age. Stilwell is very confused about this function, and he need your help. First of all,
SPOJ PHRASES 每个字符串至少出现两次且不重叠的最长子串
阳光下的泡沫
04-06 1179
Description You are the King of Byteland. Your agents have just intercepted a batch of encrypted enemy messages concerning the date of the planned attack on your island. You immedietaly send for
poj2406 连续重复子串
阳光下的泡沫
04-06 1027
Power Strings Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 41110   Accepted: 17099 Description Given two strings a and b we define a*b to be their conca
2015陕西 并查集
阳光下的泡沫
06-14 948
某国家的网络传输系统可以看作是以首都Town为中心的有向树，一开始只是Town建有基站，所有其他城市的信号全是从Town传输过来的，现在他们开始在其他城市建立基站，城市的编号为1->n；其中城市1为首都，"C x"代表在城市x处建立基站，Q代表询问。 输入：每组数据包含2个正整数n和m（1 输出：对于每个查询输出一个数 样例： 3    4        1    2  
POJ2352线段树
最新发布
08-28
POJ 2352题目通常涉及“线段树”（Segment Tree），它是一种数据结构，主要用于处理区间查询和更新的问题。线段树实质上是一个数组，每个元素代表一段连续的输入序列。通过分治策略，将原问题划分到每个叶子节点上，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值