[luogu P3391] 文艺平衡树

时间：2024-11-23 20:07:07

[luogu P3391] 文艺平衡树

题目背景

这是一道经典的Splay模板题——文艺平衡树。

题目描述

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

输入输出格式

输入格式：

第一行为n,m n表示初始序列有n个数，这个序列依次是(1,2, \cdots n-1,n)(1,2,⋯n−1,n) m表示翻转操作次数

接下来m行每行两个数 [l,r][l,r] 数据保证 1 \leq l \leq r \leq n1≤l≤r≤n

输出格式：

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

输入输出样例

输入样例#1： 复制 
5 3
1 3
1 3
1 4
输出样例#1： 复制 
4 3 2 1 5

说明

n,m≤100000

上次就很想写了，splay的妙用。

splay能做到一般的平衡树做不到的东西——维护序列。

为什么一般的平衡树做不到？正是因为splaytree的核心操作——splay。

这个log级别的操作能将一个连续的子序列搞到一棵子树中。

比如要维护[l,r]，则调用一下splay(find(l-1),0),splay(find(r+1),root)。

但是要注意一下，对于这题，我们需要一个节点在当前序列的排名和初始位置（即权值）。

一个节点的排名是它的左子树大小+1，初始位置是不变的。

对于这题，还有一个巧妙的地方，就是reverse操作。

这里用到了和线段树类似的lazy打标记，延迟下传的思想。还是很厉害的。

输出的话，根据二叉搜索树的性质，直接中序遍历。

code：

 #include <cstdio>
 #include <iostream>

 void OJ_file() {
     #ifndef ONLINE_JUDGE
         freopen("in.txt","r",stdin);
         freopen("out.txt","w",stdout);
     #endif
 }
 namespace fastIO {
     #define puc(c) putchar(c)
     inline int read() {
         ,f=; char ch=getchar();
         ') {
             if (ch=='-') f=-f;
             ch=getchar();
         }
         ') {
             x=(x<<)+(x<<)+ch-';
             ch=getchar();
         }
         return x*f;
     }
     ];
     template <class T> inline void write(T x) {
         ) {
             puc('); return;
         }
         ) x=-x,puc('-');
         ; x; x/=) w[++cnt]=x%;
         );
     }
     inline void newblank() {
         puc(' ');
     }
 } using namespace fastIO;

 int n,m;
 #define SplayTree node
 struct SplayTree {
     int v,k; bool r;
     node* c[];
     node () {
         v=k=r=;
         c[]=c[]=c[]=;
     }
 }*ro;
 void newnode (node* &x,int k) {
     x=,x->k=k;
 }
 void refresh (node* x) {
     x->v=;
     ]) x->v+=x->c[]->v;
     ]) x->v+=x->c[]->v;
 }
 void transfer (node* x) {
     if (x->r) {
         ]) x->c[]->r^=;
         ]) x->c[]->r^=;
         x->r=,std::swap(x->c[],x->c[]);
     }
 }
 #define M ((l)+(r)>>1)
 void setup (node* &x,int l,int r) {
     if (l>r) return;
     newnode(x,M);
     setup(x->c[],l,M-),setup(x->c[],M+,r);
     ]) x->c[]->c[]=x;
     ]) x->c[]->c[]=x;
     refresh(x);
 }
 bool dir (node* x) {
     ]) ;
     ]->c[]==x;
 }
 void linknode (node* y,node* x,bool p) {
     ]=y;
     if (y) y->c[p]=x;
 }
 void rotate (node* x) {
     ];
     linknode(y->c[],x,dir(y));
     linknode(y,x->c[p^],p);
     linknode(x,y,p^);
     refresh(y),refresh(x);
 }
 void splay (node* x,node* an) {
     ]==an) return;
     ]!=an) {
         ]->c[]==an) {
             rotate(x);
             if (!an) ro=x;
             return;
         }
         rotate(dir(x)^dir(x->c[])?x:x->c[]);
         rotate(x);
     }
     if (!an) ro=x;
 }
 node* find (node* x,int v) {
     transfer(x);
     ]?x->c[]->v:;
     if (v==s) return x;
     ) ],v);
     ],v-s-);
 }
 void reverse (int l,int r) {
     node* q[]={find(ro,l-),find(ro,r+)};
     splay(q[],),splay(q[],ro);
     ro->c[]->c[]->r^=;
 }
 void dfs (node* x) {
     transfer(x);
     ]) dfs(x->c[]);
     &&x->k<=n) {
         write(x->k),newblank();
     }
     ]) dfs(x->c[]);
 }
 int main() {
     OJ_file();
     n=read(),m=read(),ro=;
     setup(ro,,n+);
     int l,r;
     for (; m; --m) {
         l=read(),r=read();
         if (l==r) continue;
         reverse(l,r);
     }
     dfs(ro);
     ;
 }

相关文章