[Tyvj 1729] 文艺平衡树

题面如下:

Tyvj 1729 文艺平衡树

Time Limit: 1 Sec  Memory Limit: 128 MB

Description

您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作：翻转一个区间，例如原有序序列是5 4 3 2 1，翻转区间是[2,4]的话，结果是5 2 3 4 1 

Input

第一行为n,m n表示初始序列有n个数，这个序列依次是(1,2……n-1,n)  m表示翻转操作次数
接下来m行每行两个数[l,r] 数据保证 1<=l<=r<=n 

Output

输出一行n个数字，表示原始序列经过m次变换后的结果 

Sample Input

5 3
1 3
1 3
1 4

Sample Output

4 3 2 1 5

啊,又是一道板子题

题目要求支持的操作只有区间翻转,其中定位需要维护$size$,翻转要维护翻转标记,所以总体来说还是比较好写的.Splay写这题思路也很明确,每次Splay区间左/右端点的左/右边结点到根/根的右孩子,然后对根的右子结点的左子树打翻转标记即可w

直接贴代码w

GitHub

/*********************************
      Judge Result:Accepted

*********************************/
#include <cstdio>
#include <vector>
#include <cstring>
#include <cstring>
#include <iostream>
#include <algorithm>

#define lch chd[0]
#define rch chd[1]
#define kch chd[k]
#define xch chd[k^1]

const int INF=0x2FFFFFFF;

class SplayTree{
private:
    struct Node{
        int k;
        int sz;
        bool rev;
        Node* prt;
        Node* chd[2];
        Node(const int& key){
            this->k=key;
            this->sz=1;
            this->prt=NULL;
            this->lch=NULL;
            this->rch=NULL;
            this->rev=false;
        }
        ~Node(){
            if(this->lch!=NULL)
                delete this->lch;
            if(this->rch!=NULL)
                delete this->rch;
        }
        inline void Maintain(){
            if(this!=NULL)
                this->sz=this->lch->size()+this->rch->size()+1;
        }
        inline void Swap(){
            if(this!=NULL){
                this->rev=!this->rev;
                std::swap(this->lch,this->rch);
            }
        }
        inline void PushDown(){
            if(this->rev){
                this->rev=false;
                this->lch->Swap();
                this->rch->Swap();
            }
        }
        inline int key(){
            return this==NULL?0:this->k;
        }
        inline int size(){
            return this==NULL?0:this->sz;
        }
    }*root;
    inline void Rotate(Node* root,int k){
        Node* tmp=root->xch;
        root->PushDown();
        tmp->PushDown();
        tmp->prt=root->prt;
        if(root->prt==NULL)
            this->root=tmp;
        else if(root->prt->lch==root)
            root->prt->lch=tmp;
        else
            root->prt->rch=tmp;
        root->xch=tmp->kch;
        if(tmp->kch!=NULL)
            tmp->kch->prt=root;
        tmp->kch=root;
        root->prt=tmp;
        root->Maintain();
        tmp->Maintain();
    }
    void Splay(Node* root,Node* prt=NULL){
        while(root->prt!=prt){
            int k=root->prt->lch==root;
            if(root->prt->prt==prt){
                Rotate(root->prt,k);
            }
            else{
                int d=root->prt->prt->lch==root->prt;
                Rotate(k==d?root->prt->prt:root->prt,k);
                Rotate(root->prt,d);
            }
        }
    }
    Node* Build(const std::vector<int>& v,int l,int r){
        if(l>r)
            return NULL;
        int mid=(l+r)>>1;
        Node* tmp=new Node(v[mid]);
        tmp->lch=Build(v,l,mid-1);
        tmp->rch=Build(v,mid+1,r);
        if(tmp->lch!=NULL)
            tmp->lch->prt=tmp;
        if(tmp->rch!=NULL)
            tmp->rch->prt=tmp;
        tmp->Maintain();
        return tmp;
    }
    void PrintTree(Node* root,int deep){
        for(int i=0;i<deep;i++)
            fputc(' ',stderr);
        fprintf(stderr, "(root=0x%X,key=%dsize=%d)
", root,root->key(),root->size());
        if(root==NULL)
            return;
        PrintTree(root->lch,deep+1);
        PrintTree(root->rch,deep+1);
    }
public:
    SplayTree(){
        this->root=new Node(-INF);
        this->root->rch=new Node(-INF);
        this->root->rch->prt=this->root;
    }
    SplayTree(const std::vector<int>& v){
        this->root=Build(v,0,v.size()-1);
    }
    ~SplayTree(){
        delete this->root;
    }
    Node* Kth(int pos){
        ++pos;
        Node* root=this->root;
        while(root!=NULL){
            root->PushDown();
            int k=root->lch->size()+1;
            if(pos<k)
                root=root->lch;
            else if(pos==k)
                return root;
            else{
                pos-=k;
                root=root->rch;
            }
        }
        return NULL;
    }
    inline void Reverse(const int& l,const int& r){
        this->Splay(this->Kth(l-1));
        this->Splay(this->Kth(r+1),this->root);
        this->root->rch->lch->Swap();
        this->root->rch->Maintain();
        this->root->Maintain();
    }
    inline void Insert(const int& pos,SplayTree* data){
        this->Splay(this->Kth(pos));
        this->Splay(this->Kth(pos+1),this->root);
        Node* tmp=data->root;
        data->root=NULL;
        this->root->rch->lch=tmp;
        tmp->prt=this->root->rch;
        this->root->rch->Maintain();
        this->root->Maintain();
    }
    void Print(){
        this->PrintTree(this->root,0);
    }
};

int FastRead();

int main(){
    freopen("sph.in","r",stdin);
    freopen("sph.out","w",stdout);
    SplayTree* tree=new SplayTree();
    std::vector<int> v;
    int n=FastRead();
    int m=FastRead();
    int a,b;
    for(int i=1;i<=n;i++){
        v.push_back(i);
    }
    tree->Insert(0,new SplayTree(v));
    for(int i=0;i<m;i++){
        a=FastRead();
        b=FastRead();
        tree->Reverse(a,b);
    }
    for(int i=1;i<=n;i++){
        printf("%d ",tree->Kth(i)->key());
    }
    putchar('
');
    return 0;
}

int FastRead(){
    int ans=0;
    bool neg=false;
    register char ch=getchar();
    while(!isdigit(ch)){
        if(ch=='-')
            neg=true;
        ch=getchar();
    }
    while(isdigit(ch)){
        ans=ans*10+ch-'0';
        ch=getchar();
    }
    if(neg)
        ans=-ans;
    return ans;
}

然后放图~