伸展树

/*
 * 维修数列 NOI 
 * 经典的伸展树的题目。
 * 题目首先给出一个数列，然后进行下列6种操作
 * 1:INSERT post tot c1,c2,...ctot :在当前数列的第pos个数字后插入tot个数字
 * 2:DELETE pos tot : 从当前数列的第pos个数字开始连续 删除tot个数字
 * 3:MAKE-SAME pos tot c :将当前数列的第pos个数字开始连续的tot个数字统一修改为c
 * 4:REVERSE pos tot : 翻转当前数列的第pos个数字来说的连续的tot个数字
 * 5:GET-SUM pos tot :计算当前数列的第pos个数字来说的连续的tot个数字的和并输出
 * 6：MAX-SUM ：求出当前数列中和最大的一段序列，输出最大和
 */
//伸展树是比线段树更强大的树形结构，对于线段树无法支持的插入和删除节点区间的操作，伸展树可以解决，而且线段树能够完成的事情伸展树都能做，但是伸展树的编程代码量更大
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <algorithm>
using namespace std;
//根节点的右子节点的左子节点 
#define Key_value ch[ch[root][1]][0]
const int MAXN=500010;
const int INF=0x3f3f3f3f;
int pre[MAXN],ch[MAXN][2],key[MAXN],size[MAXN];
//sum求区间和，也是子树和 | rev 子树反转的延时标记 | same 子树区间被给定值赋值的延时标记  
int sum[MAXN],rev[MAXN],same[MAXN];
int lx[MAXN],rx[MAXN],mx[MAXN];
int root,tot1;
//s内存池 
int s[MAXN],tot2;
int a[MAXN];
int n,q;

//重构树的中序遍历除了1 , 2节点也就是排除得到的序列的头尾两个数之后得到的序列一定和原来的输入序列相同 
void Inorder(int r){
    if(!r)return;
    Inorder(ch[r][0]);
    printf("%d ",key[r]);
    Inorder(ch[r][1]);
}

//建立伸展树 

void NewNode(int &r,int father,int k){
    //分配新节点标号 
    //内存池分配内存给r节点 
    if(tot2)r=s[tot2--];
    //增加节点 
    else r=++tot1;
    //r节点的父节点，再区间看来没什么用，但是是维护树形结构和伸展树的时候用的 
    pre[r]=father;
    //新节点的左右节点为空 
    ch[r][0]=ch[r][1]=0;
    //key值，节点的值，树形结构的节点有一个key值，保存着该节点所代表的区间的中间值，就是区间的一个值，但是该节点所代表的子树依旧代表着一个区间，因为除了key值，其他参数都在维护区间的属性值，比如区间连续和的最大值，区间和，区间节点总数等等 
    key[r]=k;
    //sum值区间和，求区间和，只需要将给定的区间翻转到根节点的右子节点的的左子节点，就是给定的区间和 
    sum[r]=k;
    //翻转序列 和区间赋值同一个数字的操作的延时标记 
    rev[r]=same[r]=0;
    //lx rx mx 和区间连续和的最大值有关，区间连续和的最大值就保存在mx里面，但是怎么计算他们的我还没看懂 
    lx[r]=rx[r]=mx[r]=k;
    //以r为根的树的节点规模，这个数组和求第k个数有关，也就是Get_kth用到 
    size[r]=1;
}
void Update_Same(int r,int v){
    //如果左右子节点为空，返回 
    if(!r)return;
    //用父节点的值更新子节点 
    key[r]=v;
    //左右子节点的和，被v替换之后 
    sum[r]=v*size[r];

    lx[r]=rx[r]=mx[r]=max(v,v*size[r]);

    //该子区间的所有节点都被修改相同， same标记相同 
    same[r]=1;
}
//r节点的翻转 
void Update_Rev(int r){
    //左右子节点为空，返回 
    if(!r)return;
    swap(ch[r][0],ch[r][1]);
    swap(lx[r],rx[r]);
    rev[r] ^= 1;//这里要注意，一定是异或1
}
void Push_Up(int r){
    //左右子树 
    int lson=ch[r][0],rson=ch[r][1];
    //更新size 
    size[r]=size[lson]+size[rson]+1;
    //和 
    sum[r]=sum[lson]+sum[rson]+key[r];

    //r节点的最值 
    //r节点左边lx的最大值是左子区间的lx和左子区间合并右子区间的lx和该节点的和的最值 
    lx[r]=max(lx[lson],sum[lson]+key[r]+max(0,lx[rson]));
    //r节点右边rx的最大值是右子区间的rx和右子区间合并左子区间的rx和该节点的和的最值 
    rx[r]=max(rx[rson],sum[rson]+key[r]+max(0,rx[lson]));
    //整个区间的和是左右区间和r值合并的值 
    mx[r]=max(0,rx[lson])+key[r]+max(0,lx[rson]);
    //r区间的最大连续和是三个值取最值 
    mx[r]=max(mx[r],max(mx[lson],mx[rson]));
}
//如果r区间有反转或者让同一区间的所有值相同的操作，就让他在下一次的伸展或者查询第k个值的时候进行完成操作，这样把本该在上一次完成的操作，用rev和same延时标记标记出来，使得在下一次进行伸展或者寻找的时候在O(1)的时间内进行用父节点进行修改 
void Push_Down(int r){

    //用父节点的key值更新子节点 
    //延时标记和旋转标记 
    if(same[r]){
        Update_Same(ch[r][0],key[r]);
        Update_Same(ch[r][1],key[r]);
        same[r]=0;
    }
    if(rev[r]){
        Update_Rev(ch[r][0]);
        Update_Rev(ch[r][1]);
        rev[r]=0;
    }
}
//father为x的父节点，x表示需要被插入数据的位置，区间[l,r] 提供x需要的数据值 
void Build(int &x,int l,int r,int father){
    //区间 
    if(l>r)return;
    //划分左右子区间 
    int mid=(l+r)/2;
    //添加新节点 
    NewNode(x,father,a[mid]);
    //x的左子树， 左子树边界，父节点x 
    Build(ch[x][0],l,mid-1,x);
    //x的右子树，右子树边界， 父节点x 
    Build(ch[x][1],mid+1,r,x);
    //自下而上更新x 
    Push_Up(x);
}
void Init(){
    root=tot1=tot2=0;
    ch[root][0]=ch[root][1]=pre[root]=size[root]=same[root]=rev[root]=sum[root]=key[root]=0;
    lx[root]=rx[root]=mx[root]=-INF;
    //根节点 root = 1 
    NewNode(root,0,-1);
    //右子节点 为2 
    NewNode(ch[root][1],root,-1);
    for(int i=0;i<n;i++)scanf("%d",&a[i]);
    //右子节点的左子节点，区间边界， 右子节点 
    Build(Key_value,0,n-1,ch[root][1]);
    Push_Up(ch[root][1]);
    Push_Up(root);
}


//旋转，kind = 0左旋，kind = 1 右旋 
void Rotate(int x,int kind){
    int y=pre[x];

    //y表示x的父节点 
    Push_Down(y);
    Push_Down(x);

    //对节点r，将祖父节点调整到父节点的子节点位置， 
    //如果是为左旋，即kind = 0 ， 则将x节点的左孩子替换掉y的右孩子，即x的位置，此时x处于独立子树的状态；如果y有父节点，就用x代表的子树替换掉y的位置，此时y处于独立子树状态；之后将y子树放到x子树的左子节点处，完成左旋
    //如果是为右旋，即kind = 1 ， 则将x节点的右孩子替换掉y的左孩子，即x的位置，此时x处于独立子树的状态；如果y有父节点，就用x代表的子树替换掉y的位置，此时y处于独立子树状态；之后将y子树放到x子树的右子节点处，完成右旋
    //旋转操作实际上就是取x的子树替换到x的位置，让缺失一半的x子树独立出来替换y的位置，然后将y子树放到x子树缺失的左子树或右子树上 

    //取x子树替换到x的位置 
    ch[y][!kind]=ch[x][kind];
    pre[ch[x][kind]]=y;

    //取让独立出来的x子树替换y的位置 
    if(pre[y])
        ch[pre[y]][ch[pre[y]][1]==y]=x;
    pre[x]=pre[y];

    //让独立出来的y子树替换x的缺失的子树的位置 
    ch[x][kind]=y;
    pre[y]=x;

    Push_Up(y);
}
//Splay调整,将第r节点调整到goal位置的右子节点位置 
void Splay(int r,int goal){    
    Push_Down(r);
    //将r节点调整到goal位置的右子节点的位置，每次循环处理一或二个节点，即父节点和祖父节点 
    while(pre[r]!=goal){
        //将r节点调整到goal位置的右子节点处，当前处理一次节点 
        if(pre[pre[r]]==goal){

            //这题有反转操作，需要先push_down,再判断左右孩子
            Push_Down(pre[r]);
            Push_Down(r);
            //处理一次节点 
            Rotate(r,ch[pre[r]][0]==r);
        }
        //处理两次节点 
        else {
            Push_Down(pre[pre[r]]);
            Push_Down(pre[r]);
            Push_Down(r);
            //父节点 

            int y=pre[r];
            int kind=ch[pre[y]][0]==y;

            //两个方向不同，先左旋在右旋 
            if(ch[y][kind]==r){
                Rotate(r,!kind);
                Rotate(r,kind);
            }
            //两个方向相同，相同方向连续两次旋转 
            else{
                Rotate(y,kind);
                Rotate(r,kind);
            }
        }
    }

    Push_Up(r);
    //如果是调整到0位置的子节点，那么该节点为根节点，因为0节点表示空节点 
    if(goal==0)root=r;
}
//返回第k个节点的前一个节点的在伸展树树形结构的编号下标 
//返回k节点的前一个节点 
int Get_Kth(int r,int k){
    //用根节点更新左右子节点 
    Push_Down(r);
    //r节点的左子节点的size大小加一 
    int t=size[ch[r][0]]+1;
    //伸展树使用左右子树的节点规模划分左右字数 
    //伸展树实际上和线段树相似，都是按照区间划分子节点，不过是取了中间节点代表该节点 
    //如果r代表区间[a , b] ，则用 (a + b) / 2 的位置的数作为r节点的key值，而size代表r节点所代表区间的所有数的个数
    //如果左子区间的size加1 则实际代表r节点的 [a , 向下取整( ( a + b) /2 ) +1 ] 区间的数的个数，  
    //如果k等于这个个数，就代表k处于r节点的中间位置，那么r节点就是k节点的父节点。返回k节点的父节点r 
    if( k == t)
        return r;
    //k在r节点的左子树里面，搜索左子树 
    if( k < t )
        return Get_Kth(ch[r][0],k);
    //k在r节点的右子树里面，搜索右子树，k节点在右子树的位置是k-t位置，应用线段树求k大的思想就是在右子树的第k大 
    else 
        return Get_Kth(ch[r][1],k-t);
}



//在第pos个数后插入tot个数
void Insert(int pos,int tot){
    for(int i=0;i<tot;i++)scanf("%d",&a[i]);
    //logn 重构树，将要插入位置的前一个节点旋转到根节点，后一个节点旋转到根节点的右子节点
    //插入的数列插入到根节点右子树的左子树上，此时左子树是一个空树 
    Splay( Get_Kth( root,pos+1 ) , 0 );
    Splay( Get_Kth( root,pos+2 ) , root );

    //插入新数列 
    Build(Key_value,0,tot-1,ch[root][1]);

    //维护区间值 
    Push_Up(ch[root][1]);
    Push_Up(root);
}

//回收内存，回收以r节点为根的整棵子树的内存，实际上是将节点保存到s数组里面了 
void erase(int r){
    if(!r)return;
    s[++tot2]=r;
    erase(ch[r][0]);
    erase(ch[r][1]);
}
//从第pos个数开始连续删除tot个数
void Delete(int pos,int tot){
    //删除的是[pos , pos + tot ] 区间点数，将pos前一个数调整到根节点和将pos+tot的后一个节点调整到根节点的右子节点 
    //pos的前一个节点调整到根节点，注意Get_Kth返回的是给定节点的前一个节点的编号 
    Splay(Get_Kth(root,pos),0);
    //返回pos + tot后一个节点的编号 
    Splay(Get_Kth(root,pos+tot+1),root);
    //回收区间[pos , pos + tot ]，也就是删除该区间的子树 
    erase(Key_value);
    //该子树在根节点的右子节点的左子节点上，删除之后将根节点的右子节点的左子节点置空 
    pre[Key_value]=0;
    Key_value=0;

    //维护区间值 
    Push_Up(ch[root][1]);
    Push_Up(root);
}
//从第pos个数连续开始的tot个数修改为c
void Make_Same(int pos,int tot,int c){
    //重构树 
    Splay(Get_Kth(root,pos),0);
    Splay(Get_Kth(root,pos+tot+1),root);

    //用给定的c数字修改区间， 让区间所有数字相同 
    Update_Same(Key_value,c);

    //维护区区间 
    Push_Up(ch[root][1]);
    Push_Up(root);
}
//反转
void Reverse(int pos,int tot){
    //重构树 
    Splay(Get_Kth(root,pos),0);
    Splay(Get_Kth(root,pos+tot+1),root);

    //反转 ，区间修改操作让在下一次区间查询的时候在push_down里面完成区间相同和反转的赋值和操作 
    Update_Rev(Key_value);

    //维护区间值 
    Push_Up(ch[root][1]);
    Push_Up(root);
}

//求和
int Get_Sum(int pos,int tot){
    //求和操作，将区间起点的前一个节点旋转到根节点
    //将区间尾点得后一个节点旋转到根节点的右子节点
    //那么根节点的右子节点的左子树表示的区间就是目标区间
    //时间复杂度，查找第k个数复杂度logn , 旋转复杂度logn ，常数不过10 
    Splay(Get_Kth(root,pos) ,0);  
    Splay(Get_Kth(root,pos+tot+1),root);
    //区间和在根节点右子节点左子节点上 
    return sum[Key_value];
}

//得到最大和
int Get_MaxSum(int pos,int tot){
    Splay(Get_Kth(root,pos),0);
    Splay(Get_Kth(root,pos+tot+1),root);
    //mx 给定的区间内连续数列的最大和 
    return mx[Key_value];
}



int main(){
    while(scanf("%d%d",&n,&q)==2){
        Init();        
        char op[20];
        int x,y,z;
        while(q--){
            scanf("%s",op);
            if(op[0]=='I'){
                scanf("%d%d",&x,&y);
                Insert(x,y);
            }
            else if(op[0]=='D'){
                scanf("%d%d",&x,&y);
                Delete(x,y);
            }
            else if(op[0]=='M'&&op[2]=='K'){
                scanf("%d%d%d",&x,&y,&z);
                Make_Same(x,y,z);
            }
            else if(op[0]=='R'){
                scanf("%d%d",&x,&y);
                //使用延时标记，将 [x,x+y]区间的子树的根节点的rev赋值为1，
                //然后在下一次伸展或者寻找第k个数的时候完成反转操作 
                Reverse(x,y);
            }
            else if(op[0]=='G'){
                scanf("%d%d",&x,&y);
                printf("%d\n",Get_Sum(x,y));
            }
            else{
                //要求整个区间的最大连续和，需要去掉根节点的两个数， 也就是size[root]-2,应为有两个节点1,2节点不是区间的节点，他们不保存区间的数 
                printf("%d\n",Get_MaxSum(1,size[root]-2));
            }
        }
    }
    return 0;
}