UVA 11922 Permutation Transformer (Splay 区间翻转 + 复制粘贴)

【解题方法】和HDU3487一样，可以看这里:http://blog.csdn.net/just_sort/article/details/52350025

【代码君】在上个代码的基础上稍微改一改就可以a了。

//
//Created by just_sort 2016/10/14
//Copyright (c) 2016 just_sort.All Rights Reserved
//

#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 300005;
#define Key_value ch[ch[root][1]][0]
int n,q;
int size[maxn],pre[maxn],key[maxn],num[maxn],rev[maxn];
int ch[maxn][2],tot,root;
inline void newnode(int &r,int k,int father)
{
    r=++tot;
    ch[r][0]=ch[r][1]=0;
    pre[r]=father;
    rev[r]=0;
    key[r]=k;
}
inline void pushup(int r)
{
    size[r]=size[ch[r][0]]+size[ch[r][1]]+1;
}
void pushdown(int r)
{
    if(rev[r])
    {
        swap(ch[r][0],ch[r][1]);
        rev[ch[r][0]]^=1;
        rev[ch[r][1]]^=1;
        rev[r]=0;
    }
}
void Build(int &r,int L,int R,int father)
{
    if(L>R) return ;
    int mid=(L+R)/2;
    newnode(r,mid,father);
    Build(ch[r][0],L,mid-1,r);
    Build(ch[r][1],mid+1,R,r);
    pushup(r);
}
void init()
{
    tot=root=0;
    ch[root][0]=ch[root][1]=pre[root]=rev[root]=size[root]=0;
    newnode(root,-1,0);
    newnode(ch[root][1],-1,root);
    size[root]=2;
    Build(Key_value,1,n,ch[root][1]);
    pushup(ch[root][1]);
    pushup(root);
}
void Rotate(int x,int kind)
{
    int y=pre[x];
    pushdown(y);
    pushdown(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;
    pushup(y);
}
void Splay(int r,int goal)
{
    pushdown(r);
    while(pre[r]!=goal)
    {
        if(pre[pre[r]]==goal)
        {
            Rotate(r,ch[pre[r]][0]==r);
            pushdown(pre[r]);
            pushdown(r);
        }
        else
        {
            pushdown(pre[pre[r]]);
            pushdown(pre[r]);
            pushdown(r);
            int y=pre[r];
            int kind=(ch[pre[y]][0]==y);
            if(ch[y][kind]==r)
            {
                Rotate(r,!kind);
                Rotate(r,kind);
            }
            else
            {
                Rotate(y,kind);
                Rotate(r,kind);
            }
        }
    }
    pushup(r);
    if(goal==0) root=r;
}
int get_Kth(int r,int k)
{
    pushdown(r);
    int t=size[ch[r][0]];
    if(t==k-1) return r;
    if(t>=k) return get_Kth(ch[r][0],k);
    else return get_Kth(ch[r][1],k-t-1);
}
int get_Min(int r)
{
    pushdown(r);
    while(ch[r][0])
    {
        r=ch[r][0];
        pushdown(r);
    }
    return r;
}
int get_Max(int r)
{
    pushdown(r);
    while(ch[r][1])
    {
        r=ch[r][1];
        pushdown(r);
    }
    return r;
}
void Reversal(int a,int b)
{
    int x=get_Kth(root,a);
    int y=get_Kth(root,b+2);
    Splay(x,0);
    Splay(y,root);
    rev[Key_value]^=1;
}
void cut(int a,int b,int c)
{
    int x=get_Kth(root,a);
    int y=get_Kth(root,b+2);
    Splay(x,0);
    Splay(y,root);
    int tmp=Key_value;
    Key_value=0;
    pushup(ch[root][1]);
    pushup(root);
    int z=get_Kth(root,c+1);
    Splay(z,0);
    int m=get_Min(ch[root][1]);
    Splay(m,root);
    Key_value=tmp;
    pre[Key_value]=ch[root][1];
    pushup(ch[root][1]);
    pushup(root);
}
int cnt;
void Inorder(int r)
{
    if(r==0) return ;
    pushdown(r);
    Inorder(ch[r][0]);
    if(cnt>=1&&cnt<=n)
    {
        printf("%d\n",key[r]);
    }
    cnt++;
    Inorder(ch[r][1]);
}

int main()
{
    while(scanf("%d%d",&n,&q)!=EOF)
    {
        if(n==-1&&q==-1) break;
        init();
        while(q--)
        {
           int a,b,c;
           scanf("%d%d",&a,&b);
           Reversal(a,b);
           c = n - ( b - a + 1);
           cut(a,b,c);
        }
        cnt=0;
        Inorder(root);
    }
    return 0;
}