#include<queue>

#include<cstdio>

#include<cstdlib>

#include<iostream>

//#include<algorithm>

using namespace std;

#define N 500005

#define INF 1e9

int tot,root;

int pri[N],val[N];

int sum[N],mxr[N],mxl[N],mx[N];

int ch[N][],siz[N];

bool rev[N];

int tag[N];

int pos,cnt,w;

int a[N];

queue<int>trash;

int st[N],top;

void read(int &x)

{

    x=; int f=; char c=getchar();

    while(!isdigit(c)) { if(c=='-') f=-; c=getchar();}

    while(isdigit(c)) { x=x*+c-''; c=getchar();}

    x*=f;

}

inline int& max(int &x, int &y) { return x > y ? x : y; }

void update(int x)

{

    int l=ch[x][],r=ch[x][];

    siz[x]=siz[l]+siz[r]+;

    sum[x]=sum[l]+sum[r]+val[x];

    mx[x]=max(mx[l],mx[r]);

    mx[x]=max(mx[x],mxr[l]+val[x]);

    mx[x]=max(mx[x],mxl[r]+val[x]);

    mx[x]=max(mx[x],mxr[l]+mxl[r]+val[x]);

    mx[x]=max(mx[x],val[x]);

    mxr[x]=max(mxr[r],sum[r]+mxr[l]+val[x]);

    mxr[x]=max(mxr[x],sum[r]+val[x]);

    mxl[x]=max(mxl[l],sum[l]+mxl[r]+val[x]);

    mxl[x]=max(mxl[x],sum[l]+val[x]);

}

void down(int x)

{

    if(rev[x])

    {

        int l=ch[x][],r=ch[x][];

        if(l)

        {

            swap(ch[l][],ch[l][]);

            swap(mxl[l],mxr[l]);

            rev[l]^=;

        }

        if(r)

        {

            swap(ch[r][],ch[r][]);

            swap(mxl[r],mxr[r]);

            rev[r]^=;

        }

        rev[x]^=;

    }

    if(tag[x]!=INF)

    {

        int l=ch[x][],r=ch[x][];

        if(l)

        {

            val[l]=tag[x];

            sum[l]=mxl[l]=mxr[l]=mx[l]=siz[l]*tag[x];

            tag[l]=tag[x];

        }

        if(r)

        {

            val[r]=tag[x];

            sum[r]=mxl[r]=mxr[r]=mx[r]=siz[r]*tag[x];

            tag[r]=tag[x];

        }

        tag[x]=INF;

    }

}       

int newnode(int v)

{

    int now;

    if(!trash.empty()) now=trash.front(),trash.pop();

    else now=++tot;

    siz[now]=;

    val[now]=v;

    pri[now]=rand();

    tag[now]=INF;

    sum[now]=mx[now]=mxl[now]=mxr[now]=v;

    rev[now]=false;

    ch[now][]=ch[now][]=;

    return now;

}

int build(int l,int r)

{

    int now,last; top=;

    for(int i=l;i<=r;++i)

    {

        now=newnode(a[i]);

        last=;

        while(top && pri[st[top]]>pri[now])

        {

            update(st[top]);

            last=st[top--];

        }

        if(top) ch[st[top]][]=now;

        ch[now][]=last; st[++top]=now;

    }

    while(top) update(st[top--]);

    return st[];

}

void split(int now,int p,int &x,int &y)

{

    if(!now) x=y=;

    else

    {

        down(now);

        if(p<=siz[ch[now][]])

        {

            y=now;

            split(ch[now][],p,x,ch[now][]);

        }

        else

        {

            x=now;

            split(ch[now][],p-siz[ch[now][]]-,ch[now][],y);

        }

        update(now);

    }

}

int merge(int x,int y)

{

    if(x) down(x);

    if(y) down(y);

    if(!x || !y) return x+y;

    if(pri[x]<pri[y])

    {

        ch[x][]=merge(ch[x][],y);

        update(x);

        return x;

    }

    else

    {

        ch[y][]=merge(x,ch[y][]);

        update(y);

        return y;

    }

}

int find(int k)

{

    int now=root;

    while()

    {

        down(now);

        if(k<=siz[ch[now][]]) now=ch[now][];

        else

        {

            k-=siz[ch[now][]];

            if(k==) return now;

            k--;

            now=ch[now][];

        }

    }

}

void insert()

{

    read(pos); read(cnt);

    pos++;

    for(int i=;i<=cnt;++i) read(a[i]);

    int rt=build(,cnt);

    int a,b;

    split(root,pos,a,b);

    int e=merge(a,rt);

    root=merge(e,b);

}   

void del(int x)

{

    if(!x) return;

    trash.push(x);

    del(ch[x][]);

    del(ch[x][]);

}

void solve(int ty)

{

    read(pos); read(cnt);

    pos++;

    int a,b;

    split(root,pos+cnt-,a,b);

    int c,d;

    split(a,pos-,c,d);

    if(ty==)

    {

        del(d);

        root=merge(c,b);

        return;

    }

    if(ty==)

    {

        read(w);

        tag[d]=w;

        val[d]=w;

        sum[d]=mxl[d]=mxr[d]=mx[d]=siz[d]*w;

    }

    else if(ty==)

    {

        rev[d]^=;

        swap(ch[d][],ch[d][]);

        swap(mxl[d],mxr[d]);

    }

    else if(ty==) printf("%d\n",sum[d]);

    root=merge(merge(c,d),b);

}

int main()

{

    mx[]=mxl[]=mxr[]=-7e8;

    int n,m;

    read(n); read(m);

    for(int i=;i<=n+;++i) read(a[i]);

    a[]=a[n+]=-7e8;

    root=build(,n+);

    char s[];

    while(m--)

    {

        scanf("%s",s);

        if(s[]=='I') insert();

        else if(s[]=='D') solve();

        else if(s[]=='K') solve();

        else if(s[]=='R') solve();

        else if(s[]=='G') solve();

        else printf("%d\n",mx[root]);

    }

}

输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。
第2行包含N个数字，描述初始时的数列。
以下M行，每行一条命令，格式参见问题描述中的表格。
任何时刻数列中最多含有500 000个数，数列中任何一个数字均在[-1 000, 1 000]内。
插入的数字总数不超过4 000 000个，输入文件大小不超过20MBytes。

对于输入数据中的GET-SUM和MAX-SUM操作，向输出文件依次打印结果，每个答案（数字）占一行。

9 8
2 -6 3 5 1 -5 -3 6 3
GET-SUM 5 4
MAX-SUM
INSERT 8 3 -5 7 2
DELETE 12 1
MAKE-SAME 3 3 2
REVERSE 3 6
GET-SUM 5 4
MAX-SUM

-1
10
1
10