bzoj1251 序列终结者（Splay Tree+懒惰标记）

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。

【思路】

Splay
Tree+懒惰标记。

用Splay Tree维护序列，添加flip，maxv，addv作为结点信息，其中flip与addv是懒惰标记，需要在Splay中调用pushdown下传标记。对于每次操作，将区间lr分裂出来后执行即可。

【代码】

 #include<cstdio>
 #include<cstring>
 #include<iostream>
 using namespace std;

 const int maxn = +;
 const int INF = 1e9;
 inline int read() {
     char c=getchar();
     while(!isdigit(c)) c=getchar();
     int x=;
     while(isdigit(c)) {
         x=x*+c-'';
         c=getchar();
     }
     return x;
 }

 struct Node {
     Node* ch[];
     int v,s,flip,addv,maxv;
     int cmp(int k) const {
         int d=k - ch[]->s;
         if(d==) return -;
         return d<=? :;
     }
     void pushdown() {
         if(addv) {
             v+=addv;
             ch[]->addv+=addv,ch[]->addv+=addv;
             addv=;
         }
         if(flip) {
             flip=;  swap(ch[],ch[]);  ch[]->flip^=,ch[]->flip^=;
         }
     }
     void maintain() {
         s=ch[]->s+ch[]->s+;
         maxv=max(ch[]->v,ch[]->v),maxv=max(maxv,v);
     }
 };
 Node* null=new Node();
 void rotate(Node* &o,int d) {
     Node* k=o->ch[d^]; o->ch[d^]=k->ch[d],k->ch[d]=o;
     o->maintain(),k->maintain(); o=k;
 }
 void splay(Node* &o,int k) {    //splay 的同时pushdown 下传标记
     o->pushdown();
     int d=o->cmp(k);
     if(d==) k-=o->ch[]->s+;
     if(d!=-) {
         Node* p=o->ch[d];
         p->pushdown();
         int d2=p->cmp(k);
         int k2=d2==? k-p->ch[]->s-:k;
         if(d2!=-) {
             splay(p->ch[d2],k2);
             if(d==d2) rotate(o,d^);  else rotate(o->ch[d],d);
         }
         rotate(o,d^);
     }
 }
 Node* merge(Node* left,Node* right) {
     splay(left,left->s);
     left->ch[]=right,left->maintain();
     return left;
 }
 void split(Node* o,int k,Node* &left,Node* &right) {
     splay(o,k);
     left=o,right=left->ch[],left->ch[]=null,left->maintain();
 }
 struct SplaySeq {
     int n;
     Node *root,seq[maxn];
     Node* build(int sz) {
         if(!sz) return null;
         Node* l=build(sz/);
         Node* o=&seq[++n];
         o->v=,o->maxv=-INF;
         o->ch[]=l,o->ch[]=build(sz-sz/-);
         o->flip=o->s=;
         o->maintain();
         return o;
     }
     void init(int sz) {
         n=null->s=null->addv=;
         null->v=null->maxv=-INF;
         root=build(sz);
     }
 }ss;

 int n,m;
 int main() {
     n=read(),m=read();
     ss.init(n+);
     int k,l,r,v;
     Node *left,*right,*mid;
     for(int i=;i<m;i++) {
         k=read(),l=read(),r=read();
         split(ss.root,l,left,right),split(right,r-l+,mid,right);
         switch(k) {
             case :
                 v=read(); mid->addv+=v;
                 break;
             case :
                 mid->flip^=;
                 break;
             case :
                 printf("%d\n",mid->maxv);
                 break;
         }
         ss.root = merge(merge(left,mid),right);
     }
     return ;
 }