POJ3580 SuperMemo SPLAY 各种操作。。。。

最新推荐文章于 2019-11-17 11:08:32 发布
最新推荐文章于 2019-11-17 11:08:32 发布
阅读量934 收藏 1
点赞数
分类专栏： splay 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lenleaves/article/details/8847436
版权

这道题目需要实现SPLAY的各种操作。。。。。码了大半天，幸亏1A，否则今晚是不用睡觉了。。。。。

一共六个操作

1：删除第K个节点

2：在第k个节点后面插入一个数

3：将区间[l,r]翻转

4：将区间[l,r]每个节点加上一个数

5：查询区间[l,r]的最小值

以上五种操作都很基本，只不过维护两个lazy标记而已，push_down的时候多做一步而已，关键是下面那个操作。

6：在区间[l,r]上做循环左移t次的操作，本质合并两个相邻的区间[a,b][b+1,c];这里两个区间的分界我们可以用t对（b-a+1）取模得到z然后右边的区间是【y-z+1，y】，具体的区间交换方法是将a-1旋转的ROOT ，然后将b旋转到ROOT的右儿子，然后将c旋转到ROOT的右儿子的右儿子。这里有特殊之处，以往我们需要操作的区间位于一个儿子节点的左子树。而这次我们要操作的区间是一个儿子节点和他的左子树。也就是说b连同他的左子树是我们要查找的[a,b]区间，c连同他的左子树是我们要查找的区间[b+1,c]然后做树进行操作就行了，这里要注意改变位置前要push_down，改变位置后要push_up 这两个操作不要啦。。。宁愿多写也不要少写。。。。

注意点：revovle操作里面的t可能为负。另外当求出的位移值为0是不需要操作此处要特判。

 

 

 

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

 

#include<iostream>
#include<cstring>
#include<algorithm>
#include<string>
#include<cstdio>

using namespace std;

#define MAXN 200000
#define INF 0x3ffffff

int a[MAXN],m,n;
int next[MAXN];
struct nodes
{
    int ch[2],f;
    int key,size,w,col,ad,mi;
}node[MAXN];

void init()
{
    for(int i=0;i<MAXN-10;i++)
        next[i]=i+1;
}

int newnode(int key)
{
    int p=next[0];
    next[0]=next[p];
    node[p].key=key;
    node[p].w=node[p].size=1;
    node[p].mi=key;
    node[p].ad=node[p].col=0;
    node[p].ch[0]=node[p].ch[1]=node[p].f=0;
    return p;
}

void delnode(int p)
{
    next[p]=next[0];
    next[0]=p;
}

struct spt
{
    int root;
    void clear()
    {
        root=0;
    }
    void rotate(int x,int c)
    {
        int y=node[x].f;
        push_down(y);push_down(x);
        node[y].ch[!c]=node[x].ch[c];
        if(node[x].ch[c])
                node[node[x].ch[c]].f=y;
        node[x].f=node[y].f;
        if(node[y].f)
        {
            if(node[node[y].f].ch[0]==y)
                node[node[y].f].ch[0]=x;
            else
                node[node[y].f].ch[1]=x;
        }
        node[x].ch[c]=y;
        node[y].f=x;
        push_up(y);
        if(y==root) root=x;
    }
    void splay(int x,int f)
    {
        push_down(x);
        for(;node[x].f!=f;)
        {
            push_down(node[node[x].f].f);
            push_down(node[x].f);
            push_down(x);
            if(node[node[x].f].f==f)
            {
                if(node[node[x].f].ch[0]==x)
                    rotate(x,1);
                else
                    rotate(x,0);
            }
            else
            {
                int y=node[x].f;
                int z=node[y].f;
                if(node[z].ch[0]==y)
                {
                    if(node[y].ch[0]==x)
                        rotate(y,1),rotate(x,1);
                    else
                        rotate(x,0),rotate(x,1);
                }
                else
                {
                    if(node[y].ch[1]==x)
                        rotate(y,0),rotate(x,0);
                    else
                        rotate(x,1),rotate(x,0);
                }
            }
        }
        push_up(x);
        if(!f) root=x;
    }
    void remove()
    {
        int t=root;
        if(node[t].ch[1])
        {
            root=node[root].ch[1];
            select(1,0);
            node[root].ch[0]=node[t].ch[0];
            if(node[t].ch[0]) node[node[t].ch[0]].f=root;
        }
        else root=node[root].ch[0];
        node[root].f=0;
        push_up(root);
        delnode(t);
    }
    void revolve(int a,int b,int c)
    {
        int pa,pb,pc,px;
        pa=select(a,0);
        pb=select(b+1,pa);
        pc=select(c+1,pb);
        px=node[pc].ch[1];
        push_down(pa);
        push_down(pb);
        push_down(pc);
        node[pa].ch[1]=pc,node[pc].f=pa;
        node[pb].ch[1]=px,node[px].f=pb;
        node[pc].ch[1]=pb,node[pb].f=pc;
        push_up(pb);
        push_up(pc);
        push_up(pa);
    }
    void reverse(int l,int r)
    {
        select(l,0);
        select(r+2,root);
        node[node[node[root].ch[1]].ch[0]].col^=1;
    }
    void insert(int x,int a)
    {
        int p=newnode(a);
        select(x+1,0);
        x=getmin(node[root].ch[1]);
        splay(x,root);
        node[node[root].ch[1]].ch[0]=p;
        node[p].f=x;
        push_up(p);
        push_up(node[root].ch[1]);
        push_up(root);
    }
    int minA2B(int a,int b)
    {
        select(a,0);
        select(b+2,root);
        push_up(node[root].ch[1]);
        push_up(root);
        return node[node[node[root].ch[1]].ch[0]].mi;
    }
    int select(int k,int rt)
    {
        int tmp,t=root;
        for(;;)
        {
            push_down(t);
            int l=node[node[t].ch[0]].size;
            if(k>l && k<=l+node[t].w) break;
            if(k<=l)
                t=node[t].ch[0];
            else
                k-=(l+node[t].w),t=node[t].ch[1];
        }
        splay(t,rt);
        return t;
    }
    int getmin(int p)
    {
        push_down(p);
        while(node[p].ch[0])
        {
            p=node[p].ch[0];
            push_down(p);
        }
        return p;
    }
    void add(int l,int r,int a)
    {
        select(l,0);
        select(r+2,root);
        node[node[node[root].ch[1]].ch[0]].key+=a;
        node[node[node[root].ch[1]].ch[0]].ad+=a;
        node[node[node[root].ch[1]].ch[0]].mi+=a;
    }
    void push_down(int rt)
    {
        if(rt && node[rt].col)
        {
            swap(node[rt].ch[0],node[rt].ch[1]);
            int l=node[rt].ch[0];
            int r=node[rt].ch[1];
            node[l].col^=1;
            node[r].col^=1;
            node[rt].col=0;
        }
        if(rt && node[rt].ad)
        {
            int l=node[rt].ch[0];
            int r=node[rt].ch[1];
            node[l].key+=node[rt].ad;
            node[r].key+=node[rt].ad;
            node[l].ad+=node[rt].ad;
            node[r].ad+=node[rt].ad;
            node[l].mi+=node[rt].ad;
            node[r].mi+=node[rt].ad;
            node[rt].ad=0;
        }
    }
    void push_up(int rt)
    {
        if(!rt)return;
        int l=node[rt].ch[0];
        int r=node[rt].ch[1];
        int ll=INF,rr=INF;
        int ret=node[rt].w;
        if(l) ret+=node[l].size,ll=node[l].mi;
        if(r) ret+=node[r].size,rr=node[r].mi;
        node[rt].size=ret;
        node[rt].mi=min(node[rt].key,min(ll,rr));
    }
    void del(int p)
    {
        if(!p) return;
        del(node[p].ch[0]);
        del(node[p].ch[1]);
        delnode(p);
    }
    int build(int l,int r,int f)
    {
        if(l>r) return 0;
        int m=(l+r)>>1;
        int p=newnode(a[m]);
        node[p].f=f;
        node[p].ch[0]=build(l,m-1,p);
        node[p].ch[1]=build(m+1,r,p);
        push_up(p);
        return p;
    }
};
spt s1;
void prepare()
{
    s1.clear();
    s1.root=newnode(INF);
    node[s1.root].ch[1]=newnode(INF);
    node[node[s1.root].ch[1]].f=s1.root;
    node[node[s1.root].ch[1]].ch[0]=s1.build(1,n,node[s1.root].ch[1]);
    s1.push_up(node[s1.root].ch[1]);
    s1.push_up(s1.root);
}

int main()
{
    char q[10];
    int x,y,z;
    init();
    while(~scanf("%d",&n))
    {
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        prepare();
        scanf("%d",&m);
        for(int i=0;i<m;i++)
        {
            scanf("%s",q);
            if(strcmp(q,"ADD")==0)
            {
                scanf("%d%d%d",&x,&y,&z);
                s1.add(x,y,z);
            }
            if(strcmp(q,"REVERSE")==0)
            {
                scanf("%d%d",&x,&y);
                s1.reverse(x,y);
            }
            if(strcmp(q,"INSERT")==0)
            {
                scanf("%d%d",&x,&y);
                s1.insert(x,y);
            }
            if(strcmp(q,"DELETE")==0)
            {
                scanf("%d",&x);
                s1.select(x+1,0);
                s1.remove();
            }
            if(strcmp(q,"MIN")==0)
            {
                scanf("%d%d",&x,&y);
                printf("%d\n",s1.minA2B(x,y));
            }
            if(strcmp(q,"REVOLVE")==0)
            {
                scanf("%d%d%d",&x,&y,&z);
                z=(z%(y-x+1)+(y-x+1))%(y-x+1);
                if(z==0) continue;
                s1.revolve(x,y-z,y);
            }
        }
        s1.del(s1.root);
    }
    return 0;
}


 

Albafica
关注
专栏目录
POJ3580 SuperMemo （Splay Tree的各种操作）
Sunshine_cfbsl
08-17 614
这题基本上就是SplaySplay TreeTree维护区间的终极题了。 AC后就能领悟到SplaySplay TreeTree的真谛（O_O） Splay Tree模板戳这里 题目大意： 对于一个数列{A1,A2,...,An}\{A_1,A_2,...,A_n\}，写一个程序能够实现以下操作： ADD x y D：给数列{Ax,...,Ay}\{A_x,...,A_y\}中的每一个数都增
HDU3487 Play with Chain SPLAY 区间分裂，区间合并，区间翻转
04-24 1238
这道题目涉及了伸展树的分裂特点。 这里注意，当我们要对伸展树做区间分裂操作的时候，我们要添加开始于结尾两个点，用于防范边界情况。输出时特殊判断即可。具体做法是在build建树之前先手动给root一个值0然后给root的右儿子一个值n+1，这样我们就形成了一个区间【0，n+1】，然后我们在将要建立的1-n这棵树放在root的右儿子的左子树上。这里一定要理解。因为以后我们对伸展树的区间操作都是这种方
poj3580 SuperMemo splay --- 从入门到入土
forOnward的博客
11-17 347
(太可怕了，我只是一个刚学懂splay的蒟蒻） poj地址：http://poj.org/problem?id=3580 AcWing地址：https://www.acwing.com/problem/content/268/ 题意： 给你一个数列 A1~An 有几个操作： 输入格式 第一行包含一个整数 n。 接下来 n 行给出了序列中的数。 接下来一行包含一个整数 ...
POJ 3580 SuperMemo splay 翻转 右移
humeay的博客
12-09 462
很多解释都在代码里… 听说这种题叫填空题….ORZ 开始在insert(x+1,y+1)然后超时了….. WA的话注意一下每次是否进行Push_up 每次改变区间的值都要及时的向上Push_up，否则直接询问得不到需要的MIN#include<stdio.h> #include<string.h> #include<iostream> #include<algorithm> #includ
poj 3580 SuperMemo splay树模板题
sepNINE的专栏
04-24 1207
splay树 模板题
Super-Memo-poj3580.zip_memo
最新发布
09-24
但是，根据提供的信息，我们可以推测这个压缩包的内容主要围绕着Splay Tree的理论、实现以及如何应用于POJ3580问题的解决方案。对于想要学习Splay Tree或者解决类似问题的人来说，这是一个宝贵的资源。
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.rar_poj java_poj1048
09-24
【标题】"POJ.rar_poj java_poj1048" 涉及的知识点主要围绕编程竞赛中的“约瑟夫环”问题，这里是一个加强版，使用Java语言进行解决。 【描述】"POJ1048，加强版的约瑟夫问题 难度中等" 提示我们，这个问题是编程...
NOI2004 郁闷的出纳员 SPLAY
04-14 1635
郁闷的出纳员。我比他还郁闷，谢了将近两天，终于把第一到SPLAY写完了，之前一直用的treap但觉得splay的功能强大，有必要学一下。当然，当treap足够解决的时候还是用treap比较好，毕竟代码量要少点，不容易出错。 splay能够很好的对区间进行处理。 刚开始各种纠结，打算一个一个的删除，但由于判断加进了push_down 函数，程序直接爆掉，后来发现根本不能这么操作，因为这样会让程序
POJ2352 Stars 树状数组
09-03 1241
树状数组。因为Y坐标已经有序，所以直接统计当前star输入后，其x坐标左侧的星星数量（前面输入的star一定比后面的y坐标小。）然后+1即可，注意x坐标要左移1。因为数据存在x=0的情况。 罪过放松了好多天。 Stars Time Limit: 1000MS   Memory Limit: 65536K Total Submissio
POJ2155 Matrix 树状数组
09-04 1234
二维的树状数组，解题思想详见《浅谈信息学竞赛中的“0”和“1”》这篇论文，我上传了一份 http://download.csdn.net/detail/lenleaves/4548401 。很经典的题目，很经典的思想。 Matrix Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 128
BZOJ2631 tree 动态树
06-07 1206
注意用unsigned int ，一开始用long long我的动态树直接被卡出翔。 这道题目与AHOI2009的拿到线段树维护延迟标记的方法是一样的，先乘再加 ，这道题目要维护子树的大小（用来加）。 操作 + u v c   区间u到v之间的路径都加c * u v c 区间u到v之间的路径都乘c - u1 v1 u2 v2 断开（u1，v1）连上（u2，v2） / u v 查询
SDOI2011 染色 动态树
06-05 1203
动态树，将区间染色，统计区间内颜色的段数。 这种区间统计题目，注意下推的时候要连续下推2层，与维修数列相同。 2243: [SDOI2011]染色 Time Limit: 20 Sec  Memory Limit: 512 MB Submit: 1041  Solved: 422 [Submit][Status][Discuss] Description
POJ3253 Fence Repair stl+哈夫曼树
06-18 1078
用顶小堆计算哈夫曼树的总权。 每次取出最小的两个顶点，权值相加，然后加入答案中，然后在讲合并和后的值加入堆中，直到只有一个节点是结束。 因为这种方法，一个叶子节点会被重复加他的深度次 Fence Repair Time Limit: 2000MS   Memory Limit: 65536K Total Submissions: 18840   A
HDU3966 Aragorn's Story 树链剖分
05-30 1076
裸地不能在裸的树链剖分了，col忘记清空，狂wa一小时。 本来想学LINK CUT TREE的，考试接踵，做题状态全无。== ==暂时顺延了 Aragorn's Story Time Limit: 10000/3000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submis
HDU4010 Query on The Trees 动态树
06-03 1008
我只能说忽略了细节啊。 大家第一次写动态树的时候注意了。由于ACCESS的时候改变一个节点的左右儿子的值，但是但是你左右儿子的父节点的值时不会被修改的！！！！！！！ 所以rotate这么写的人太注意了，一个else WA了一整天啊啊 if(node[y].f) { if(node[node[y].f].ch[0]==y) node[no
UVA11997 K Smallest Sums 多路归并（优先队列）
05-21 989
//多路归并问题 //把k个有序表合并成一个有序表。 //大于2是两两归并 //本题只要求出k个最小的，所以可以限制上限 //k个整数数组，每个数组包含k个数，在每个数组中 //去一个数加起来，得到K^K个和 //求这些和中的最小的k个值 K Smallest Sums You're given k arrays, each array has k integers
HNOI2010 Bounce 弹飞绵羊 动态树
06-04 980
如果i能弹到j，则将i和j相连 i的弹力系数修改后，先断开原来的边，然后与新的边连接即可。 统计每一个子树的节点数。输出的时候-1； 2002: [Hnoi2010]Bounce 弹飞绵羊 Time Limit: 10 Sec  Memory Limit: 259 MB Submit: 2567  Solved: 1382 [Submit][Status][Discuss]
POJ图论题目集锦：Dijkstra、A*与集合操作
"这篇资料是关于POJ在线判题系统中的图论题目集合，包含了多个经典图论问题的解题指引和链接。" 在图论这个广泛的领域中，解决计算机科学中的许多问题都需要用到图的概念。POJ（Problem Online Judge）是一个著名的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值