HDU3487 Play with Chain SPLAY 区间分裂，区间合并，区间翻转

关注

原创最新推荐文章于 2016-01-10 20:04:03 发布 1.3k 阅读 AI 写同款· GEO 优化 ›

AI权益加码！Claude Code、Cursor等20+工具免费用！购周边限时加赠Coding Plan Lite，畅享主流AI工具！学习进阶更高效！阅读详情

这道题目涉及了伸展树的分裂特点。

这里注意，当我们要对伸展树做区间分裂操作的时候，我们要添加开始于结尾两个点，用于防范边界情况。输出时特殊判断即可。具体做法是在build建树之前先手动给root一个值0然后给root的右儿子一个值n+1，这样我们就形成了一个区间【0，n+1】，然后我们在将要建立的1-n这棵树放在root的右儿子的左子树上。这里一定要理解。因为以后我们对伸展树的区间操作都是这种方法，假如要提取区间【a,b】那么我们就要将a-1旋转到根，b+1旋转到根的右儿子。然后很显然，右儿子的左子树就是我们所要找的区间。

CUT a,b,c 这个操作要求我们将区间[a,b]分裂出来然后添加在第c个数后面。具体取法与上面相同。这里说一下合并到c之后的方法，做法就是将C旋转到root，然后将右子树的最小值旋转到右子树的根，然后我们在将区间插入右子树的左子树。

FLIP a,b 区间翻转。

这里要注意下。我上面说的a，b都是从左往右第a或第b个数。

总结一下关键字：区间，root的右儿子的左子树。

我的splay。。。好长的代码量啊，，，能用treap我一定不用splay。。。。。

Play with Chain

Time Limit: 6000/2000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 2429 Accepted Submission(s): 980

Problem Description

YaoYao is fond of playing his chains. He has a chain containing n diamonds on it. Diamonds are numbered from 1 to n.
At first, the diamonds on the chain is a sequence: 1, 2, 3, …, n.
He will perform two types of operations:
CUT a b c: He will first cut down the chain from the ath diamond to the bth diamond. And then insert it after the cth diamond on the remaining chain.
For example, if n=8, the chain is: 1 2 3 4 5 6 7 8; We perform “CUT 3 5 4”, Then we first cut down 3 4 5, and the remaining chain would be: 1 2 6 7 8. Then we insert “3 4 5” into the chain before 5th diamond, the chain turns out to be: 1 2 6 7 3 4 5 8.

FLIP a b: We first cut down the chain from the ath diamond to the bth diamond. Then reverse the chain and put them back to the original position.
For example, if we perform “FLIP 2 6” on the chain: 1 2 6 7 3 4 5 8. The chain will turn out to be: 1 4 3 7 6 2 5 8

He wants to know what the chain looks like after perform m operations. Could you help him?

Input

There will be multiple test cases in a test data.
For each test case, the first line contains two numbers: n and m (1≤n, m≤3*100000), indicating the total number of diamonds on the chain and the number of operations respectively.
Then m lines follow, each line contains one operation. The command is like this:
CUT a b c // Means a CUT operation, 1 ≤ a ≤ b ≤ n, 0≤ c ≤ n-(b-a+1).
FLIP a b // Means a FLIP operation, 1 ≤ a < b ≤ n.
The input ends up with two negative numbers, which should not be processed as a case.

Output

For each test case, you should print a line with n numbers. The ith number is the number of the ith diamond on the chain.

Sample Input

  
   8 2
CUT 3 5 4
FLIP 2 6
-1 -1

Sample Output

  
   1 4 3 7 6 2 5 8

Source

2010 ACM-ICPC Multi-University Training Contest（5）——Host by BJTU

//SPLAY   分裂区间【a,b】添加在c后面， 区间【a,b】翻转
#include<iostream>
#include<cstring>
#include<algorithm>
#include<string>
#include<cstdio>

using namespace std;

#define MAXN 500000

int next[MAXN];
struct nodes
{
    int ch[2],f;
    int key,size,w,col;
}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=1;
    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;
    }
    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;
    }
    void split(int l,int r,int &s2)
    {
        select(l,0);
        select(r+2,root);
        int tmp=node[node[root].ch[1]].ch[0];
        node[node[root].ch[1]].ch[0]=0;
        push_up(node[root].ch[1]);
        push_up(root);
        s2=tmp;
    }
    void reverse(int l,int r)
    {
        select(l,0);
        select(r+2,root);
        node[node[node[root].ch[1]].ch[0]].col^=1;
    }
    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;
        }
    }
    void push_up(int rt)
    {
        if(!rt)return;
        int l=node[rt].ch[0];
        int r=node[rt].ch[1];
        int ret=node[rt].w;
        if(l) ret+=node[l].size;
        if(r) ret+=node[r].size;
        node[rt].size=ret;
    }
    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(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;
    }
    int getmin(int p)
    {
        push_down(p);
        while(node[p].ch[0])
        {
            p=node[p].ch[0];
            push_down(p);
        }
        return p;
    }
    void cut(int a,int b,int c)
    {
        spt tmp;
        split(a,b,tmp.root);
        select(c+1,0);
        c=getmin(node[root].ch[1]);
        splay(c,root);
        node[node[root].ch[1]].ch[0]=tmp.root;
        node[tmp.root].f=c;
        push_up(node[root].ch[1]);
        push_up(root);
    }
};

spt s1;
int n,m,cnt;
char s[20];

void solve(int p)
{
    if(!p) return;
    s1.push_down(p);
    solve(node[p].ch[0]);
    if(node[p].key!=0 && node[p].key!=n+1)
    {
        cnt++;
        printf("%d%s",node[p].key,cnt!=n?" ":"\n");
    }
    solve(node[p].ch[1]);
}

void prepare()
{
    s1.clear();
    s1.root=newnode(0);
    node[s1.root].ch[1]=newnode(n+1);
    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()
{
    int a,b,c;
    init();
    while(~scanf("%d%d",&n,&m))
    {
        if(n==-1 && m==-1) break;
        prepare();
        for(int i=0;i<m;i++)
        {
            scanf("%s",s);
            if(strcmp(s,"FLIP")==0)
            {
                scanf("%d%d",&a,&b);
                s1.reverse(a,b);
            }
            else
            {
                scanf("%d%d%d",&a,&b,&c);
                s1.cut(a,b,c);
            }
        }
        cnt=0;
        solve(s1.root);
        s1.del(s1.root);
    }
    return 0;
}

收录于