洛谷 P3391 【模板】文艺平衡树（Splay）

先记一发非旋treap，splay什么的以后再说

基本就是正常的非旋treap维护序列加上一个flip标记，如果某个节点flip为true表示以它为根的子树需要一次翻转。类似线段树lazytag

每次可能要修改某个节点o的任意ch之前，都对o进行一次pushdown。（就是split和merge中）

pushdown的操作是交换o的两个子节点，再将两个子节点的flip标记异或1。

每次进行翻转操作（翻转[l,r]），就把整个序列split成三段[1,l-1]，[l,r]，[r+1,size]。然后直接将中间一段的根节点的flip标记异或1，再merge回去就行了。

曾经错误：72行两个语句反了；实际上flip不需要修改split和merge，不要多此一举

#include<cstdio>
#include<algorithm>
#include<ctime>
using namespace std;
template<typename T>
class MyVec
{
private:
    static const int M_SIZE=200001;
    int rand1()
    {
        static int x=471;
        return x=(48271LL*x+1)%2147483647;
    }
public:
    struct Node
    {
        Node(){}
        Node* ch[2];
        int r;
        bool flip;
        //表示该节点的所有子节点需要flip 
        T v;
        int size;
        void upd()
        {
            size=1+(ch[0]?ch[0]->size:0)+(ch[1]?ch[1]->size:0);
        }
        void pushdown()
        {
            if(flip)
            {
                Node* t=ch[0];ch[0]=ch[1];ch[1]=t;
                if(ch[0])    (ch[0]->flip)^=1;
                if(ch[1])    (ch[1]->flip)^=1;
                flip=0;
            }
        }
    }nodes[M_SIZE];
private:
    Node* root;
    Node* que[M_SIZE];
    int que_top;
    Node* getnode()
    {
        return que[que_top--];
    }
    void delnode(Node* x)
    {
        que[++que_top]=x;
    }
    Node* merge(Node* a,Node* b)
    {
        if(a==NULL)    return b;
        if(b==NULL)    return a;
        if(a->r < b->r)
        {
            a->pushdown();a->ch[1]=merge(a->ch[1],b);a->upd();
            return a;
        }
        else
        {
            b->pushdown();b->ch[0]=merge(a,b->ch[0]);b->upd();
            return b;
        }
    }
    typedef pair<Node*,Node*> P;
    P split(Node* a,int n)
    {
        if(a==NULL)    return P(NULL,NULL);
        P y;
        a->pushdown();int s=a->ch[0] ? a->ch[0]->size : 0;
        if(s>=n)
        {
            y=split(a->ch[0],n);
            a->ch[0]=y.second;a->upd();
            y.second=a;
        }
        else
        {
            y=split(a->ch[1],n-s-1);
            a->ch[1]=y.first;a->upd();
            y.first=a;
        }
        return y;
    }
    Node* kth(Node* o,int k)
    {
        if(o==NULL||k<=0||k > o->size)    return NULL;
        P y=split(root,k-1);
        P y2=split(y.second,1);
        root=merge(merge(y.first,y2.first),y2.second);
        return y2.first;
    }
    void erase(Node* &o,int k)
    {
        if(o==NULL||k<=0||k > o->size)    return;
        P y=split(root,k-1);
        P y2=split(y.second,1);
        delnode(y2.first);
        root=merge(y.first,y2.second);
    }
public:
    //在第k个之前插入
    void insert(int k,const T& x)
    {
        Node* t=getnode();
        t->ch[0]=t->ch[1]=NULL;t->r=rand1();t->v=x;t->flip=0;t->upd();
        P y=split(root,k-1);
        root=merge(merge(y.first,t),y.second);
    }
    MyVec()
    {
        que_top=M_SIZE-1;
        for(int i=0;i<M_SIZE;i++)    que[i]=nodes+i;
        root=NULL;
    }
    void push_back(const T& x)
    {
        insert(size()+1,x);
    }
    void pop_back()
    {
        erase(root,root->size);
    }
    void push_front(const T& x)
    {
        insert(1,x);
    }
    void pop_front()
    {
        erase(root,1);
    }
    Node* find_by_order(int k)
    {
        return kth(root,k);
    }
    T& operator[](int k)
    {
        return kth(root,k)->v;
    }
    void erase(int k)
    {
        erase(root,k);
    }
    int size()
    {
        return root ? root->size : 0;
    }
    //翻转[l,r]
    void flip(int l,int r)
    {
        P y=split(root,l-1);
        P y2=split(y.second,r-l+1);
        y2.first->flip^=1;
        root=merge(merge(y.first,y2.first),y2.second);
    }
};
MyVec<int> x;
int n,m,l,r;
int main()
{
    int i;
    scanf("%d%d",&n,&m);
    for(i=1;i<=n;i++)
        x.push_back(i);
    while(m--)
    {
        scanf("%d%d",&l,&r);
        x.flip(l,r);
    }
    for(i=1;i<=n;i++)
        printf("%d ",x[i]);
    return 0;
}