洛谷 P2042 【[NOI2005]维护数列】

一直在想要做这道题，但是被那个硕大的Splay标签压垮了

---

好了，切入正题

这道题应该是我第二次用splay来维护区间问题 我还是太菜了QAQ

其实思路也很简单，就是以每一个位置的下标来进行维护，然后其实就是跟权值树是一模一样的了

然后再具体说一下

为了保证效率，像线段树和文艺平衡树一样，我们可以维护一个\({lazytag}\),然后在需要向下查询时再向下查询就行

然后我们考虑两种标记各自下传的先后顺序

我们可以发现，如果一个区间内已经被“同化”，即进行了\(make-same\)操作，这个时候，翻转也没有了意义。

关于求最大子段和，这个部分就跟原来用线段树解决此类问题是一模一样的，维护一个gss标记，然后对其做DP就行了。

然后这一道题和其他平衡树的题最大的一点不同是它是区间插入，区间删除。为了提升效率，我们可以考虑先将每一次要加入的一段区间预处理成一棵平衡树，然后再直接插入，这样的话效率会有很大的提升

然后，这道题差不多就完了

具体就看代码吧

#pragma G++ optimize(3)
#pragma GCC optimize(3)
#pragma G++ optimize(2)
#pragma GCC optimize(2)
#pragma G++ optimize("-Ofast")
#pragma GCC optimize("-Ofast")
#include<queue>
#include<cstdio>
#include<cstring>
#define dir(p) (son[fa[p]][1]==p) 
#define inf 0x3f3f3f
using namespace std;
const int maxn=6e5+10;
char opt[30];
int n,m,ncnt,root;
queue<int>q;
int siz[maxn],son[maxn][2],sum[maxn],val[maxn];
int gss[maxn],lx[maxn],rx[maxn],fa[maxn];
int sam[maxn],rev[maxn],a[maxn],id[maxn];
void swap(int &a,int &b)
{
    a^=b^=a^=b;
}
int max(int a,int b)
{
    return a>b?a:b;
}
inline int read()
{
    register int num=0,f=1;
    register char ch=getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-') f=-1; 
        ch=getchar();
    }
    while(ch>='0'&&ch<='9'){
        num=num*10+ch-'0';
        ch=getchar();
    }
    return num*f;
}
void upd(register int t)
{
    int l=son[t][0],r=son[t][1];
    siz[t]=siz[l]+siz[r]+1;
    sum[t]=sum[l]+sum[r]+val[t];
    lx[t]=max(lx[l],sum[l]+val[t]+lx[r]);
    rx[t]=max(rx[r],sum[r]+val[t]+rx[l]);
    gss[t]=max(rx[l]+lx[r]+val[t],max(gss[l],gss[r]));
}
void pushdown(register int t)
{
    int l=son[t][0],r=son[t][1];
    if(sam[t])
    {
        sam[t]=rev[t]=0;
        if(l)
        {
            sam[l]=1,val[l]=val[t];
            sum[l]=val[l]*siz[l];
            lx[l]=rx[l]=max(sum[l],0);
            gss[l]=val[l]<0?val[l]:sum[l];
        }
        if(r)
        {
            sam[r]=1,val[r]=val[t];
            sum[r]=val[r]*siz[r];
            lx[r]=rx[r]=max(sum[r],0);
            gss[r]=val[r]<0?val[r]:sum[r];
        }
    }
    if(rev[t])
    {
        rev[t]=0,rev[l]^=1,rev[r]^=1;
        swap(lx[l],rx[l]),swap(rx[r],lx[r]);
        swap(son[l][0],son[l][1]);
        swap(son[r][0],son[r][1]);
    }
}
inline int node(register int x)
{
    int cur;
    if(q.empty()) cur=++ncnt;
    else cur=q.front(),q.pop();
    son[cur][0]=son[cur][1]=fa[cur]=0;
    val[cur]=sum[cur]=gss[cur]=x;
    lx[cur]=rx[cur]=max(0,x);
    sam[cur]=rev[cur]=0;
    siz[cur]=1;
    return cur;
}
inline int kth(register int x)
{
    int t=root;
    while(1)
    {
        pushdown(t);
        if(son[t][0]&&x<=siz[son[t][0]])
            t=son[t][0];
        else if(x>siz[son[t][0]]+1)
        {
            x-=siz[son[t][0]]+1;
            t=son[t][1];
        }
        else 
            return t;
    }
}
void rotate(register int p)
{
    int fp=fa[p],ffp=fa[fp],way=dir(p);
    son[fp][way]=son[p][way^1];
    fa[son[p][way^1]]=fp;
    son[ffp][dir(fp)]=p;
    fa[p]=ffp;
    son[p][way^1]=fp;
    fa[fp]=p;
    upd(fp),upd(p);
}
void splay(register int p,register int g)
{
    while(fa[p]!=g)
    {
        int fp=fa[p],ffp=fa[fp];
        if(ffp!=g)
        {
            if(dir(fp)==dir(p)) rotate(fp);
            else rotate(p);
        }
        rotate(p);
    }
    if(!g) root=p;
}
inline void insert(register int x,register int y)
{
    int u=kth(x+1),v=kth(x+2);
    splay(u,0),splay(v,u);
    son[v][0]=y,fa[y]=v;
    upd(v),upd(u);
}
inline void recycle(register int x)
{
    if(son[x][0]) recycle(son[x][0]);
    if(son[x][1]) recycle(son[x][1]);
    q.push(x);
}
inline void remove(register int x,register int y)
{
    int u=kth(x),v=kth(x+y+1);
    splay(u,0),splay(v,u);
    recycle(son[v][0]);
    son[v][0]=0;
    upd(v),upd(u);
}
inline int qsum(register int x,register int y)
{
    int u=kth(x),v=kth(x+y+1);
    splay(u,0),splay(v,u);
    return sum[son[v][0]];
}
int build(register int l,register int r,int *qaq)
{
    if(l>r) return 0;
    int mid=(l+r)>>1,cur=node(qaq[mid]);
    if(l==r) return cur;
    if((son[cur][0]=build(l,mid-1,qaq))) fa[son[cur][0]]=cur;
    if((son[cur][1]=build(mid+1,r,qaq)))fa[son[cur][1]]=cur;
    upd(cur);
    return cur;
}
inline void update(register int x,register int y,register int z)
{
    int u=kth(x),v=kth(x+y+1);
    splay(u,0),splay(v,u);
    int w=son[v][0];
    sam[w]=1,val[w]=z,sum[w]=siz[w]*z;
    lx[w]=rx[w]=max(sum[w],0);
    if(z<0) gss[w]=z;
    else gss[w]=sum[w];
    upd(v),upd(u);
}
inline void reverse(register int x,register int y)
{
    int u=kth(x),v=kth(x+y+1);
    splay(u,0),splay(v,u);
    int w=son[v][0];
    if(!sam[w])
    {
        rev[w]^=1;
        swap(son[w][0],son[w][1]);
        swap(lx[w],rx[w]);
        upd(v),upd(u);
    }
}
int main()
{
    n=read();
    m=read();
    for(register int i=2;i<=n+1;++i)
        a[i]=read();
    gss[0]=val[0]=-inf;
    a[1]=a[n+2]=-inf;
    n+=2;
    build(1,n,a);
    root=1;
    int pos,num,tot;
    for(register int i=1;i<=m;++i)
    {
        scanf("%s",opt);
        if(opt[0]=='I')
        {
            pos=read(),num=read();
            memset(a,0,sizeof a);
            for(register int j=1;j<=num;++j)
                a[j]=read();
            insert(pos,build(1,num,a));
        }
        else if(opt[0]=='D')
        {
            pos=read(),num=read();
            remove(pos,num);
        }
        else if(opt[0]=='M'&&opt[3]=='E')
        {
            pos=read(),num=read(),tot=read();
            update(pos,num,tot);
        }
        else if(opt[0]=='R')
        {
            pos=read(),num=read();
            reverse(pos,num);
        }
        else if(opt[0]=='G')
        {
            pos=read(),num=read();
            printf("%d\n",qsum(pos,num));
        }
        else if(opt[0]=='M'&&opt[1]=='A'&&opt[2]=='X')
            printf("%d\n",gss[root]);
    }
    return 0;
}

转载于:https://www.cnblogs.com/HenryHuang-Never-Settle/p/10539164.html