【bzoj1251】序列终结者（伸展树）

【bzoj1251】序列终结者（伸展树）

Description

网上有许多题，就是给定一个序列，要你支持几种操作：A、B、C、D。一看另一道题，又是一个序列 要支持几种操作：D、C、B、A。尤其是我们这里的某人，出模拟试题，居然还出了一道这样的，真是没技术含量……这样 我也出一道题，我出这一道的目的是为了让大家以后做这种题目有一个“库”可以依靠，没有什么其他的意思。这道题目 就叫序列终结者吧。 【问题描述】 给定一个长度为N的序列，每个序列的元素是一个整数（废话）。要支持以下三种操作： 1. 将[L,R]这个区间内的所有数加上V。 2. 将[L,R]这个区间翻转，比如1 2 3 4变成4 3 2 1。 3. 求[L,R]这个区间中的最大值。 最开始所有元素都是0。

Input

第一行两个整数N，M。M为操作个数。 以下M行，每行最多四个整数，依次为K，L，R，V。K表示是第几种操作，如果不是第1种操作则K后面只有两个数。

Output

对于每个第3种操作，给出正确的回答。

Sample Input

4 4
1 1 3 2
1 2 4 -1
2 1 3
3 2 4

Sample Output

2
【数据范围】
N<=50000，M<=100000。

样例说明：

	0	0	0	0
1 1 3 2	2	2	2	0
1 2 4 -1	2	1	1	-1
2 1 3	1	1	2	-1
3 2 4	2

分析：

暴力的话，操作1增加操作，操作2翻转操作，操作3查询操作的复杂度都是O(n)，并且有m个查询的话，O(mn)肯定得爆炸。

关键点：
1. 伸展树为左小右大的二叉树，所以旋转操作不会影响树的性质
2. 区间操作为：
int u = select(L - 1), v = select(R + 1);
splay(u, 0); splay(v, u);
//通过旋转操作把询问的区间聚集到根的右子树的左子树下
因为伸展树为左小右大的二叉树，旋转操作后的所以对于闭区间[L, R]之间的所有元素都聚集在根的右子树的左子树下
因为闭区间[L, R]，
1) 所以每次都要查开区间(L - 1, R + 1)，
2) 所以伸展树元素1对应的标号为2，
3) 所以node[0]对应空节点，node[1]对应比所以元素标号都小的点，node[2 ~ n + 1]对应元素1 ~ n，node[n + 2]对应比所有元素标号都打的点，其中node[0], node[1], node[n + 2]都是虚节点，不代表任何元素。

每次进行序列操作时，把l-1旋转到根，把r+1旋转到根的右儿子，r+1的左子树就是整个区间[l,r]。

我们可以用Splay的每个节点记录该节点对应子树的信息，那么每次询问只要输出r+1的左子树中的最大值，即代码中的mx[t[y][0]]。

为了避免Splay中有节点0，我们将所有节点的编号加1。又因为要旋转l-1和r+1，所以在Splay插入节点为1到n+2。(原因显然…大家自己脑补)

这道题用Splay的提根操作达到了区间操作的目的，方法很巧妙。

另外我觉得这道题有几点需要注意：

①要理解Splay中节点的含义以及节点所记录的信息。

②区间的翻转操作很巧妙，只需要将标记下传并且交换左右子树，并不需要修改节点的max和size。

③每次find操作都要pushdown，这样就可以保证节点x到根的路径上所有点都被更新，便于之后的旋转操作

总结

a. 这里区间加，所以无怪乎有延迟标记的思想，那就自然有了pushdown操作

b. 这里通过提根操作找到我们要操作的区间，

c. 区间加操作用的是延迟标记的思想

b. 区间最大值操作在排序二叉树中很简单（因为这个区间已经被我们旋转成一个区间了）

d. 区间翻转操作：这里用的是延迟标记的思想（区间加也是延迟标记），所以有rev做延迟标记，交换的话直接交换左右即可

e. 这里有翻转操作，这颗伸展树不一定是一颗二叉排序树，所以求最大值的话就像线段树那么求好了，每个节点多加个maxx标记即可

 /*bzoj 1251 序列终结者
   题意：
   给定一个长度为N的序列，每个序列的元素是一个整数。要支持以下三种操作：
   1. 将[L,R]这个区间内的所有数加上V;
   2. 将[L,R]这个区间翻转，比如1 2 3 4变成4 3 2 1;
   3. 求[L,R]这个区间中的最大值;
   最开始所有元素都是0。
   限制：
   N <= 50000, M <= 100000
   思路：
   伸展树
 
   关键点：
   1. 伸展树为左小右大的二叉树，所以旋转操作不会影响树的性质
   2. 区间操作为：
         int u = select(L - 1), v = select(R + 1);
         splay(u, 0); splay(v, u);    //通过旋转操作把询问的区间聚集到根的右子树的左子树下
      因为伸展树为左小右大的二叉树，旋转操作后的所以对于闭区间[L, R]之间的所有元素都聚集在根的右子树的左子树下
      因为闭区间[L, R]，
      1) 所以每次都要查开区间(L - 1, R + 1)，
      2) 所以伸展树元素1对应的标号为2，
      3) 所以node[0]对应空节点，node[1]对应比所以元素标号都小的点，node[2 ~ n + 1]对应元素1 ~ n，node[n + 2]对应比所有元素标号都打的点，其中node[0], node[1], node[n + 2]都是虚节点，不代表任何元素。
  */
 #include <iostream>
 #include <cstdio>
 using namespace std;
 //左右孩子简便写
 #define LS(n) node[(n)].ch[0]
 #define RS(n) node[(n)].ch[1]
 
 const int N = 1e5 + ;
 const int INF = 0x3f3f3f3f;
 struct Splay {
     struct Node{
         int fa, ch[];//节点的父亲以及两个孩子
         bool rev;//翻转标记
         int val, add, maxx, size;//值，增加的延迟标记，最大值，子树的大小
         void init(int _val) {
             val = maxx = _val;//初始化最大值和值
             size = ;//子树大小
             add = rev = ch[] = ch[] = ;//初始化左右子树和延迟标记和反转标记
         }
     } node[N];//n个节点
     int root;//树根 
 
     void up(int n) {//右节点向父亲更新
         //这是求子树的最大值，树的最大值就是取树根，左子树，右子树三者中的最大值
         node[n].maxx = max(node[n].val, max(node[LS(n)].maxx, node[RS(n)].maxx));
         //这是更新树根的大小，左子树+右子树+根
         node[n].size = node[LS(n)].size + node[RS(n)].size + ;
     }
 
     void down(int n) {//区间增加的延迟标记往下传的操作
         if(n == ) return ;//空节点
         if(node[n].add) {//如果增加的延迟标记不为0
             if(LS(n)) {//如果分别有左右子树，就更新左右子树
                 //标准的线段树区间操作的例子
                 node[LS(n)].val += node[n].add;
                 node[LS(n)].maxx += node[n].add;
                 node[LS(n)].add += node[n].add;
             }
             if(RS(n)) {
                 node[RS(n)].val += node[n].add;
                 node[RS(n)].maxx += node[n].add;
                 node[RS(n)].add += node[n].add;
             }
             node[n].add = ;//增加延迟标记传下去了，自己的当然要赋值为0
         }
         if(node[n].rev) {//这是区间翻转的延迟标记
             if(LS(n)) node[LS(n)].rev ^= ;//翻转延迟标记往下传
             if(RS(n)) node[RS(n)].rev ^= ;
             swap(LS(n), RS(n));//交换左右子树
             node[n].rev = ;//翻转延迟标记设置为0
         }
     }
 
     //左旋和右旋的合集 ，将节点n按照kind方式旋转
     void rotate(int n, bool kind) {
         int fn = node[n].fa;
         int ffn = node[fn].fa;
         node[fn].ch[!kind] = node[n].ch[kind];
         node[node[n].ch[kind]].fa = fn;
 
         node[n].ch[kind] = fn;
         node[fn].fa = n;
 
         node[ffn].ch[RS(ffn) == fn] = n;
         node[n].fa = ffn;
         up(fn);
     }
 
     //将节点n伸展到goal的 位置去
     void splay(int n, int goal) {
         while(node[n].fa != goal) {
             int fn = node[n].fa;
             int ffn = node[fn].fa;
             down(ffn); down(fn); down(n);
             bool rotate_n = (LS(fn) == n);
             bool rotate_fn = (LS(ffn) == fn);
             if(ffn == goal) rotate(n, rotate_n);
             else {
                 if(rotate_n == rotate_fn) rotate(fn, rotate_fn);
                 else rotate(n, rotate_n);
                 rotate(n, rotate_fn);
             }
         }
         up(n);
         if(goal == ) root = n;
     }
 
     //在树种找位置为pos的点，其实和二叉查找树里面找排名为pos的点的方式一样
     int select(int pos) {
         int u = root;
         down(u);//区间加和区级翻转延迟标记下传
         while(node[LS(u)].size != pos) {//左孩子的大小不等于pos
             if(pos < node[LS(u)].size)//如果pos在左孩子就往左孩子走
                 u = LS(u);//
             else {//pos在右孩子
                 pos -= node[LS(u)].size + ;//pos减去左孩子和根的大小
                 u = RS(u);//往右孩子走
             }
             down(u);//延迟标记下传
         }
         return u;
     }
 
     //查找l到r这个区间
     int query(int L, int R) {
         //u节点就是找到的l-1的节点，v节点就是找到的r+1的节点
         int u = select(L - ), v = select(R + );
         //将u节点旋转到0的位置（根），将v节点旋转到u的位置，那么
         splay(u, ); splay(v, u);    //通过旋转操作把询问的区间聚集到根的右子树的左子树下
         return node[LS(v)].maxx;
     }
 
     //区间加操作
     void update(int L, int R, int val) {
         //把区间调上来
         int u = select(L - ), v = select(R + );
         splay(u, ); splay(v, u);
         //标准的区间加操作
         node[LS(v)].val += val;
         node[LS(v)].maxx += val;
         node[LS(v)].add += val;//延迟标记下传
     }
 
     //区间翻转操作
     void reverse(int L, int R) {
         //找区间
         int u = select(L - ), v = select(R + );
         splay(u, ); splay(v, u);
         //翻转延迟标记置为1
         node[LS(v)].rev ^= ;
     }
 
     int build(int L, int R) {
         if(L > R) return ;
         if(L == R) return L;
         int mid = (L + R) >> ;
         int r_L, r_R;
         LS(mid) = r_L = build(L, mid - );
         RS(mid) = r_R = build(mid + , R);
         node[r_L].fa = node[r_R].fa = mid;
         up(mid);
         return mid;
     }
 
     void init(int n) {
         node[].init(-INF); node[].size = ;
         node[].init(-INF);
         node[n + ].init(-INF);
         for(int i = ; i <= n + ; ++i)
             node[i].init();
 
         root = build(, n + );
         node[root].fa = ;
 
         node[].fa = ;
         LS() = root;
     }
 } splay_tree;
 
 int main() {
     int n, m;
     scanf("%d%d", &n, &m);
     splay_tree.init(n);//初始化
     for(int i = ; i < m; ++i) {
         int op, l, r, v;
         scanf("%d", &op);
         if(op == ) {//操作1，区间加
             scanf("%d%d%d", &l, &r, &v);
             splay_tree.update(l, r, v);//l到r区间上面加上v
         } else if(op == ) {//操作2，区间翻转
             scanf("%d%d", &l, &r);
             splay_tree.reverse(l, r);//翻转l到r区间
         } else {
             scanf("%d%d", &l, &r);
             printf("%d\n",splay_tree.query(l, r));//查询l到r的最大值
         }
     }
     return ;
 }