NOI2005维护数列 伸展树splay

最新推荐文章于 2022-03-17 00:21:16 发布
最新推荐文章于 2022-03-17 00:21:16 发布
阅读量859 收藏 1
点赞数
分类专栏： 平衡树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/night_raven/article/details/12684113
版权

        7K的代码....从中午调到现在...终于调过去了.....太感动了.....

        中文的题目题意就不多说了...前五个操作都是最基本的splay操作，最后一个稍微麻烦点，可以先去做做http://blog.csdn.net/yanglei040/article/details/12625039这个题..要求某个区间的最大子段和的话，对于每个区间，要维护区间和sum，区间最大后缀suff，最大前缀pref,最大子段和sub四个值，因为在pushup的时候，sub可以是他两个子区间的sub的最大值，也可能是左孩子的suff+自己的值+右孩子的pref，前缀和后缀的更新方式也基本类似了，然后...就没有然后了..慢慢调吧，耐心调早晚能调出来的...另外有一点要注意的就是make-same操作要用两个值维护，setn表示改成多少，same表示是否有标记。因为他的数据可能有make-same x y 0的情况，如果要用setn去表示是否标记的话，搞不好就要WA到哭了，我大部分时间都坑在这里了....先贴一个没加任何优化的代码..

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
using namespace std;
typedef long long ll;
const int maxn=4000000+4000;
int pre[maxn],ch[maxn][2];
int flip[maxn];
ll setn[maxn];
int size[maxn];
ll key[maxn],sub[maxn],suff[maxn],pref[maxn],sum[maxn],a[maxn];
bool same[maxn];
int root,tot,n,m;
int p,q,tt,t,k,r;
struct splaytree
{
    void pushup(int r)
    {
        if (r==0) return;
        size[r]=size[ch[r][0]]+1+size[ch[r][1]];
        sum[r]=sum[ch[r][0]]+key[r]+sum[ch[r][1]];

        pref[r]=max(pref[ch[r][0]],sum[ch[r][0]]+key[r]+max(0LL,pref[ch[r][1]]));
        suff[r]=max(suff[ch[r][1]],sum[ch[r][1]]+key[r]+max(0LL,suff[ch[r][0]]));
        sub[r]=max(0LL,suff[ch[r][0]])+key[r]+max(0LL,pref[ch[r][1]]);
        sub[r]=max(sub[r],max(sub[ch[r][0]],sub[ch[r][1]]));
    }
    void rotate(int x,int kind)
    {
        int y=pre[x];
        pushdown(y);
        pushdown(x);
        ch[y][!kind]=ch[x][kind];
        pre[ch[x][kind]]=y;
        if (pre[y])
        {
            ch[pre[y]][ch[pre[y]][1]==y]=x;
        }
        pre[x]=pre[y];
        ch[x][kind]=y;
        pre[y]=x;
        pushup(y);
        pushup(x);
    }
    void splay(int x,int tgt)
    {
        pushdown(x);
        while(pre[x]!=tgt)
        {
            int y=pre[x];
            pushdown(pre[y]);
            pushdown(y);
            pushdown(x);
            if (pre[pre[x]]==tgt)
            {
                rotate(x,ch[pre[x]][0]==x);
            }
            else
            {
                int kind=ch[pre[y]][0]==y;
                if (ch[y][kind]==x)
                {
                    rotate(x,kind^1);
                    rotate(x,kind);
                }
                else
                {
                    rotate(y,kind);
                    rotate(x,kind);
                }
            }
        }
        pushup(x);
        if (tgt==0) root=x;
    }
    void select(int k,int tgt)
    {
        int rt=root;
        pushdown(rt);
        while(true)
        {
            if (k<=size[ch[rt][0]]) rt=ch[rt][0];
            else if (k==size[ch[rt][0]]+1) break;
            else k-=(size[ch[rt][0]]+1),rt=ch[rt][1];
            pushdown(rt);
        }
        splay(rt,tgt);
    }
    void newnode(int &r,int father,ll k)
    {
        r=++tot;
        pre[r]=father;
        size[r]=1;
        flip[r]=setn[r]=0;
        key[r]=k;
        sum[r]=suff[r]=pref[r]=sub[r]=k;
        ch[r][0]=ch[r][1]=0;
    }
    void build(int l,int r,int &x,int rt)
    {
        if (l>r) return;
        int m=(l+r)>>1;
        newnode(x,rt,a[m]);
        build(l,m-1,ch[x][0],x);
        build(m+1,r,ch[x][1],x);
        pushup(x);
    }
    void init()
    {
        tot=root=0;
        newnode(root,0,-(1<<29));
        newnode(ch[root][1],root,-(1<<29));
        suff[0]=pref[0]=sub[0]=-(1<<29);
        suff[1]=pref[1]=sub[1]=-(1<<29);
        suff[2]=pref[2]=sub[2]=-(1<<29);

        build(1,n,ch[ch[root][1]][0],ch[root][1]);
        pushup(ch[root][1]);
        pushup(root);
    }
    void go_f(int r)
    {
        if(!r) return;
        flip[r]^=1;
        swap(ch[r][0],ch[r][1]);
        swap(suff[r],pref[r]);
    }
    void go_s(int r,ll c)
    {
        if (!r) return ;
        same[r]=true;
        key[r]=c;
        setn[r]=c;
        sum[r]=(ll)(size[r]*c);
        suff[r]=pref[r]=sub[r]=max(c,(ll)size[r]*c);
    }
    void pushdownset(int r)
    {
        if (same[r])
        {
            go_s(ch[r][0],setn[r]);
            go_s(ch[r][1],setn[r]);
            same[r]=false;
//            flip[r]=0;
        }
    }
    void pushdownflip(int r)
    {
        if (flip[r])
        {
            go_f(ch[r][0]);
            go_f(ch[r][1]);
            flip[r]=0;
        }
    }
    void pushdown(int r)
    {
        pushdownset(r);
        pushdownflip(r);
    }
    void insert(int posi,int num)
    {
        ll c;
        select(posi+1,0);
        select(posi+2,root);

        scanf("%I64d",&c);
        newnode(ch[ch[root][1]][0],ch[root][1],c);
        int rt=ch[ch[root][1]][0];
        for(int i=2; i<=num; i++)
        {
            scanf("%I64d",&c);
            newnode(ch[rt][1],rt,c);
            rt=ch[rt][1];
        }
        while(pre[rt])
        {
            rt=pre[rt];
            pushup(rt);
        }
        pushup(root);
    }
    void del(int posi,int num)
    {
        select(posi,0);
        select(posi+num+1,root);
        int k=ch[ch[root][1]][0];
        pre[k]=0;
        ch[ch[root][1]][0]=0;
        pushup(ch[root][1]);
        pushup(root);
    }
    void set_num(int posi,int num,ll c)
    {
        select(posi,0);
        select(posi+num+1,root);
        go_s(ch[ch[root][1]][0],c);
        pushup(ch[root][1]);
        pushup(root);
        int k=ch[ch[root][1]][0];
//        splay(k,0);
    }
    void reverse(int posi,int num)
    {
        select(posi,0);
        select(posi+num+1,root);
        go_f(ch[ch[root][1]][0]);
        int k=ch[ch[root][1]][0];
//        splay(k,0);
    }
    ll Sum(int posi,int num)
    {
        select(posi,0);
        select(posi+num+1,root);
        return sum[ch[ch[root][1]][0]];
    }
    ll Max_sum()
    {
        splay(1,0);
        splay(2,root);
        return sub[ch[ch[root][1]][0]];
    }

}spt;
char cmd[30];
int x,y,z;
ll c;
int main()
{
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);

    scanf("%d%d",&n,&m);
    for (int i=1; i<=n; i++)
    scanf("%I64d",&a[i]);
    spt.init();
    getchar();
    for (int i=1; i<=m; i++)
    {
//        cout<<ch[0][0]<<"---"<<ch[0][1]<<"--"<<pre[0]<<"hit----\n";
        scanf("%s",cmd);
        if (cmd[0]=='G')
        {
            scanf("%d%d",&x,&y);
            printf("%I64d\n",spt.Sum(x,y));
        }
        else
        if (cmd[0]=='I')
        {
            scanf("%d%d",&x,&y);
            spt.insert(x,y);
        }
        else
        if (cmd[0]=='M' && cmd[2]=='K')
        {
            scanf("%d%d%I64d",&x,&y,&c);
            spt.set_num(x,y,c);
        }
        else
        if (cmd[0]=='R')
        {
            scanf("%d%d",&x,&y);
            spt.reverse(x,y);
        }
        else
        if (cmd[0]=='M' && cmd[2]=='X')
        {
            printf("%I64d\n",spt.Max_sum());
        }
        else
        if (cmd[0]=='D')
        {
            scanf("%d%d",&x,&y);
            spt.del(x,y);
        }
    }
    return 0;
}


 

        可以发现..时间跟内存的消耗都是惊人的...因为我直接开了400W的数组....而且insert操作的时候我是直接用while循环，插成了一条链，这样在以后旋转的时候，时间消耗会很大。题目里保证了数列里最大只有50W个数，也就是说，根本没必要开400W的数组，delete的时候，把空间回收再利用的话，50W的数组就够用了。参考了一下各路大神的代码，加上了内存回收，并且在insert的时候，直接插成一颗平衡树，时间和空间都会大大缩小。

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
using namespace std;
typedef long long ll;
const int maxn=500000+5000;
int pre[maxn],ch[maxn][2];
int stk[maxn];
int top;
int flip[maxn];
ll setn[maxn];
int size[maxn];
ll key[maxn],sub[maxn],suff[maxn],pref[maxn],sum[maxn],a[maxn];
bool same[maxn];
int root,tot,n,m;
int p,q,tt,t,k,r;
struct splaytree
{
    void pushup(int r)
    {
        if (r==0) return;
        size[r]=size[ch[r][0]]+1+size[ch[r][1]];
        sum[r]=sum[ch[r][0]]+key[r]+sum[ch[r][1]];

        pref[r]=max(pref[ch[r][0]],sum[ch[r][0]]+key[r]+max(0LL,pref[ch[r][1]]));
        suff[r]=max(suff[ch[r][1]],sum[ch[r][1]]+key[r]+max(0LL,suff[ch[r][0]]));
        sub[r]=max(0LL,suff[ch[r][0]])+key[r]+max(0LL,pref[ch[r][1]]);
        sub[r]=max(sub[r],max(sub[ch[r][0]],sub[ch[r][1]]));
    }
    void rotate(int x,int kind)
    {
        int y=pre[x];
        pushdown(y);
        pushdown(x);
        ch[y][!kind]=ch[x][kind];
        pre[ch[x][kind]]=y;
        if (pre[y])
        {
            ch[pre[y]][ch[pre[y]][1]==y]=x;
        }
        pre[x]=pre[y];
        ch[x][kind]=y;
        pre[y]=x;
        pushup(y);
        pushup(x);
    }
    void splay(int x,int tgt)
    {
        pushdown(x);
        while(pre[x]!=tgt)
        {
            int y=pre[x];
            pushdown(pre[y]);
            pushdown(y);
            pushdown(x);
            if (pre[pre[x]]==tgt)
            {
                rotate(x,ch[pre[x]][0]==x);
            }
            else
            {
                int kind=ch[pre[y]][0]==y;
                if (ch[y][kind]==x)
                {
                    rotate(x,kind^1);
                    rotate(x,kind);
                }
                else
                {
                    rotate(y,kind);
                    rotate(x,kind);
                }
            }
        }
        pushup(x);
        if (tgt==0) root=x;
    }
    void select(int k,int tgt)
    {
        int rt=root;
        pushdown(rt);
        while(true)
        {
            if (k<=size[ch[rt][0]]) rt=ch[rt][0];
            else if (k==size[ch[rt][0]]+1) break;
            else k-=(size[ch[rt][0]]+1),rt=ch[rt][1];
            pushdown(rt);
        }
        splay(rt,tgt);
    }
    void newnode(int &r,int father,ll k)
    {
        if (top)
        {
            r=stk[top--];
        }
        else r=++tot;

        pre[r]=father;
        size[r]=1;
        flip[r]=setn[r]=0;
        same[r]=0;
        key[r]=k;
        sum[r]=suff[r]=pref[r]=sub[r]=k;
        ch[r][0]=ch[r][1]=0;
    }
    void build(int l,int r,int &x,int rt)
    {
        if (l>r) return;
        int m=(l+r)>>1;
        newnode(x,rt,a[m]);
        build(l,m-1,ch[x][0],x);
        build(m+1,r,ch[x][1],x);
        pushup(x);
    }
    void init()
    {
        tot=root=0;
        top=0;
        newnode(root,0,-(1<<29));
        newnode(ch[root][1],root,-(1<<29));
        suff[0]=pref[0]=sub[0]=-(1<<29);
        suff[1]=pref[1]=sub[1]=-(1<<29);
        suff[2]=pref[2]=sub[2]=-(1<<29);

        build(1,n,ch[ch[root][1]][0],ch[root][1]);
        pushup(ch[root][1]);
        pushup(root);
    }
    void go_f(int r)
    {
        if(!r) return;
        flip[r]^=1;
        swap(ch[r][0],ch[r][1]);
        swap(suff[r],pref[r]);
    }
    void go_s(int r,ll c)
    {
        if (!r) return ;
        same[r]=true;
        key[r]=c;
        setn[r]=c;
        sum[r]=(ll)(size[r]*c);
        suff[r]=pref[r]=sub[r]=max(c,(ll)size[r]*c);
    }
    void pushdownset(int r)
    {
        if (same[r])
        {
            go_s(ch[r][0],setn[r]);
            go_s(ch[r][1],setn[r]);
            same[r]=false;
//            flip[r]=0;
        }
    }
    void pushdownflip(int r)
    {
        if (flip[r])
        {
            go_f(ch[r][0]);
            go_f(ch[r][1]);
            flip[r]=0;
        }
    }
    void pushdown(int r)
    {
        pushdownset(r);
        pushdownflip(r);
    }
    void insert(int posi,int num)
    {
        ll c;
        select(posi+1,0);
        select(posi+2,root);
        for (int i=1; i<=num; i++)
        scanf("%I64d",&a[i]);
        build(1,num,ch[ch[root][1]][0],ch[root][1]);
    }
    void del(int posi,int num)
    {
        select(posi,0);
        select(posi+num+1,root);
        int k=ch[ch[root][1]][0];
        recover(k);
        pre[k]=0;
        ch[ch[root][1]][0]=0;
        pushup(ch[root][1]);
        pushup(root);
    }
    void set_num(int posi,int num,ll c)
    {
        select(posi,0);
        select(posi+num+1,root);
        go_s(ch[ch[root][1]][0],c);
        pushup(ch[root][1]);
        pushup(root);
        int k=ch[ch[root][1]][0];
//        splay(k,0);
    }
    void reverse(int posi,int num)
    {
        select(posi,0);
        select(posi+num+1,root);
        go_f(ch[ch[root][1]][0]);
        int k=ch[ch[root][1]][0];
//        splay(k,0);
    }
    ll Sum(int posi,int num)
    {
        select(posi,0);
        select(posi+num+1,root);
        return sum[ch[ch[root][1]][0]];
    }
    ll Max_sum()
    {
        splay(1,0);
        splay(2,root);
        return sub[ch[ch[root][1]][0]];
    }
    void recover(int r)
    {
        if (!r) return;
        stk[++top]=r;
        recover(ch[r][0]);
        recover(ch[r][1]);
    }

}spt;
char cmd[30];
int x,y,z;
ll c;
int main()
{
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);

    scanf("%d%d",&n,&m);
    for (int i=1; i<=n; i++)
    scanf("%I64d",&a[i]);
    spt.init();
    getchar();
    for (int i=1; i<=m; i++)
    {
//        cout<<ch[0][0]<<"---"<<ch[0][1]<<"--"<<pre[0]<<"hit----\n";
        scanf("%s",cmd);
        if (cmd[0]=='G')
        {
            scanf("%d%d",&x,&y);
            printf("%I64d\n",spt.Sum(x,y));
        }
        else
        if (cmd[0]=='I')
        {
            scanf("%d%d",&x,&y);
            spt.insert(x,y);
        }
        else
        if (cmd[0]=='M' && cmd[2]=='K')
        {
            scanf("%d%d%I64d",&x,&y,&c);
            spt.set_num(x,y,c);
        }
        else
        if (cmd[0]=='R')
        {
            scanf("%d%d",&x,&y);
            spt.reverse(x,y);
        }
        else
        if (cmd[0]=='M' && cmd[2]=='X')
        {
            printf("%I64d\n",spt.Max_sum());
        }
        else
        if (cmd[0]=='D')
        {
            scanf("%d%d",&x,&y);
            spt.del(x,y);
        }
    }
    return 0;
}


BZOJ上交的代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
using namespace std;
typedef long long ll;
const int maxn=500000+5000;
int pre[maxn],ch[maxn][2];
int stk[maxn];
int top;
int flip[maxn];
ll setn[maxn];
int size[maxn];
ll key[maxn],sub[maxn],suff[maxn],pref[maxn],sum[maxn],a[maxn];
bool same[maxn];
int root,tot,n,m;
int p,q,tt,t,k,r;
struct splaytree
{
    void pushup(int r)
    {
        if (r==0) return;
        size[r]=size[ch[r][0]]+1+size[ch[r][1]];
        sum[r]=sum[ch[r][0]]+key[r]+sum[ch[r][1]];

        pref[r]=max(pref[ch[r][0]],sum[ch[r][0]]+key[r]+max(0LL,pref[ch[r][1]]));
        suff[r]=max(suff[ch[r][1]],sum[ch[r][1]]+key[r]+max(0LL,suff[ch[r][0]]));
        sub[r]=max(0LL,suff[ch[r][0]])+key[r]+max(0LL,pref[ch[r][1]]);
        sub[r]=max(sub[r],max(sub[ch[r][0]],sub[ch[r][1]]));
    }
    void rotate(int x,int kind)
    {
        int y=pre[x];
        pushdown(y);
        pushdown(x);
        ch[y][!kind]=ch[x][kind];
        pre[ch[x][kind]]=y;
        if (pre[y])
        {
            ch[pre[y]][ch[pre[y]][1]==y]=x;
        }
        pre[x]=pre[y];
        ch[x][kind]=y;
        pre[y]=x;
        pushup(y);
        pushup(x);
    }
    void splay(int x,int tgt)
    {
        pushdown(x);
        while(pre[x]!=tgt)
        {
            int y=pre[x];
            pushdown(pre[y]);
            pushdown(y);
            pushdown(x);
            if (pre[pre[x]]==tgt)
            {
                rotate(x,ch[pre[x]][0]==x);
            }
            else
            {
                int kind=ch[pre[y]][0]==y;
                if (ch[y][kind]==x)
                {
                    rotate(x,kind^1);
                    rotate(x,kind);
                }
                else
                {
                    rotate(y,kind);
                    rotate(x,kind);
                }
            }
        }
        pushup(x);
        if (tgt==0) root=x;
    }
    void select(int k,int tgt)
    {
        int rt=root;
        pushdown(rt);
        while(true)
        {
            if (k<=size[ch[rt][0]]) rt=ch[rt][0];
            else if (k==size[ch[rt][0]]+1) break;
            else k-=(size[ch[rt][0]]+1),rt=ch[rt][1];
            pushdown(rt);
        }
        splay(rt,tgt);
    }
    void newnode(int &r,int father,ll k)
    {
        if (top)
        {
            r=stk[top--];
        }
        else r=++tot;

        pre[r]=father;
        size[r]=1;
        flip[r]=setn[r]=0;
        same[r]=0;
        key[r]=k;
        sum[r]=suff[r]=pref[r]=sub[r]=k;
        ch[r][0]=ch[r][1]=0;
    }
    void build(int l,int r,int &x,int rt)
    {
        if (l>r) return;
        int m=(l+r)>>1;
        newnode(x,rt,a[m]);
        build(l,m-1,ch[x][0],x);
        build(m+1,r,ch[x][1],x);
        pushup(x);
    }
    void init()
    {
        tot=root=0;
        top=0;
        newnode(root,0,-(1<<29));
        newnode(ch[root][1],root,-(1<<29));
        suff[0]=pref[0]=sub[0]=-(1<<29);
        suff[1]=pref[1]=sub[1]=-(1<<29);
        suff[2]=pref[2]=sub[2]=-(1<<29);

        build(1,n,ch[ch[root][1]][0],ch[root][1]);
        pushup(ch[root][1]);
        pushup(root);
    }
    void go_f(int r)
    {
        if(!r) return;
        flip[r]^=1;
        swap(ch[r][0],ch[r][1]);
        swap(suff[r],pref[r]);
    }
    void go_s(int r,ll c)
    {
        if (!r) return ;
        same[r]=true;
        key[r]=c;
        setn[r]=c;
        sum[r]=(ll)(size[r]*c);
        suff[r]=pref[r]=sub[r]=max(c,(ll)size[r]*c);
    }
    void pushdownset(int r)
    {
        if (same[r])
        {
            go_s(ch[r][0],setn[r]);
            go_s(ch[r][1],setn[r]);
            same[r]=false;
//            flip[r]=0;
        }
    }
    void pushdownflip(int r)
    {
        if (flip[r])
        {
            go_f(ch[r][0]);
            go_f(ch[r][1]);
            flip[r]=0;
        }
    }
    void pushdown(int r)
    {
        pushdownset(r);
        pushdownflip(r);
    }
    void insert(int posi,int num)
    {
        ll c;
        select(posi+1,0);
        select(posi+2,root);
        for (int i=1; i<=num; i++)
        scanf("%lld",&a[i]);
        build(1,num,ch[ch[root][1]][0],ch[root][1]);
    }
    void del(int posi,int num)
    {
        select(posi,0);
        select(posi+num+1,root);
        int k=ch[ch[root][1]][0];
        recover(k);
        pre[k]=0;
        ch[ch[root][1]][0]=0;
        pushup(ch[root][1]);
        pushup(root);
    }
    void set_num(int posi,int num,ll c)
    {
        select(posi,0);
        select(posi+num+1,root);
        go_s(ch[ch[root][1]][0],c);
        pushup(ch[root][1]);
        pushup(root);
        int k=ch[ch[root][1]][0];
//        splay(k,0);
    }
    void reverse(int posi,int num)
    {
        select(posi,0);
        select(posi+num+1,root);
        go_f(ch[ch[root][1]][0]);
        int k=ch[ch[root][1]][0];
//        splay(k,0);
    }
    ll Sum(int posi,int num)
    {
        select(posi,0);
        select(posi+num+1,root);
        return sum[ch[ch[root][1]][0]];
    }
    ll Max_sum()
    {
        splay(1,0);
        splay(2,root);
        return sub[ch[ch[root][1]][0]];
    }
    void recover(int r)
    {
        if (!r) return;
        stk[++top]=r;
        recover(ch[r][0]);
        recover(ch[r][1]);
    }

}spt;
char cmd[30];
int x,y,z;
ll c;
int main()
{


    scanf("%d%d",&n,&m);
    for (int i=1; i<=n; i++)
    scanf("%lld",&a[i]);
    spt.init();
    getchar();
    for (int i=1; i<=m; i++)
    {
//        cout<<ch[0][0]<<"---"<<ch[0][1]<<"--"<<pre[0]<<"hit----\n";
        scanf("%s",cmd);
        if (cmd[0]=='G')
        {
            scanf("%d%d",&x,&y);
            printf("%lld\n",spt.Sum(x,y));
        }
        else
        if (cmd[0]=='I')
        {
            scanf("%d%d",&x,&y);
            spt.insert(x,y);
        }
        else
        if (cmd[0]=='M' && cmd[2]=='K')
        {
            scanf("%d%d%lld",&x,&y,&c);
            spt.set_num(x,y,c);
        }
        else
        if (cmd[0]=='R')
        {
            scanf("%d%d",&x,&y);
            spt.reverse(x,y);
        }
        else
        if (cmd[0]=='M' && cmd[2]=='X')
        {
            printf("%lld\n",spt.Max_sum());
        }
        else
        if (cmd[0]=='D')
        {
            scanf("%d%d",&x,&y);
            spt.del(x,y);
        }
    }
    return 0;
}


NightRaven
关注
专栏目录
NOI2005 维护数列
Holylight_Knight
10-10 628
NOI2005 维护数列tags :【Splay】,【BZOJ1500】,【洛谷2042】在线评测地址：洛谷，大视野题目描述1500: [NOI2005]维修数列Time Limit: 10 Sec Memory Limit: 64 MBDescriptionInput输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。第2行包含N个数字，
[NOI2005] 维护数列（平衡树）
PhantomAgony
01-26 394
题目 描述 请写一个程序，要求维护一个数列，支持以下6种操作：（请注意，格式栏中的下划线‘ _ ’表示实际输入文件中的空格） 插入 INSERT_posi_tot_c1_c2_…_ctot 在当前数列的第posi个数字后插入tot个数字：c1, c2, …, ctot；若在数列首插入，则posi为0 删除 DELETE_posi_tot 从当前数列的第posi个数字开始连续删除to
[NOI2005]维护数列——Splay
weixin_30877755的博客
07-22 60
题面 　　洛谷P2042 解析 　　　　这道题集齐了大部分Splay的经典操作，上课时wys老师讲了一下，这个题还是很值得一做的 　　基操： 　　　　Splay上的所有区间操作都需要提取区间，如果要提取一个[l, r]的区间，只需要把l-1的点转到根，再把r+1的点转到根的右儿子，那么根的右儿子的左儿子的整颗子树就是我们要提取的区间 　　操作1：插入 　　　　这个题的插入并...
P2042 [NOI2005]维护数列（Splay 维护序列区间操作，Splay下推标记）
qq_41997978的博客
02-05 242
Splay维护序列练习题，比较麻烦的是标记的下推 和 pushup 操作，两个哨兵节点的初始值应赋为无穷小避免影响操作6的答案。区间更新操作时要pushup 到 root，否则 更新点到 root 维护的信息可能有误 建树： 直接对数组用类似线段树的方法建树，由于要建立哨兵节点，哨兵节点的权值应赋为无穷小。 操作1： 找到起始位置 x，将 x 伸展到 root，并找到 x 的后继 y，y 一定...
【NOI2005】维护数列
Facico的博客
06-28 883
Description　请写一个程序，要求维护一个数列，支持以下6种操作：（请注意，格式栏中的下划线‘ _ ’表示实际输入文件中的空格） 　　1. 插入 INSERT_posi_tot_c1_c2_…_ctot 在当前数列的第posi个数字后插入tot个数字：c1, c2, …, ctot；若在数列首插入，则posi为0 　　2. 删除 DELETE_posi_tot 从当前数列的第posi个数
1500: [NOI2005]维修数列（Splay）
qq_43544481的博客
12-25 142
Description 请写一个程序，要求维护一个数列，支持以下 6 种操作： 请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格 Input 输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。 第2行包含N个数字，描述初始时的数列。 以下M行，每行一条命令，格式参见问题描述中的表格。 任何时刻数列中最多含有500 000个数...
BZOJ 1500|NOI 2005|维修数列|Splay
とある黄鱼のOIブログ
12-21 269
这题没啥好说的。。主要是用来贴模板 3.6s 尝试了抽象Splay这个类，不过卡在了内存池怎么写的问题上。。。感觉对C++理解还不够深刻。#include <cstdio> #include <stdexcept> #include <algorithm> using namespace std; #define inf 1000000000 #define N 1000005int read()
BZOJ 1500([NOI2005]维修数列-Splay的数列维护)
nike0good |Oier&ACMer | 熟能生巧
02-13 2020
1500: [NOI2005]维修数列 Time Limit: 10 Sec  Memory Limit: 64 MB Submit: 3087  Solved: 920 [Submit][Status][Discuss] Description Input 输入文件的第1行包含两个数N和M，N表示初始时数列中数的个数，M表示要进行的操作数目。 第2行包含N个数字，描述初始
伸展树(Splay tree)图解与实现
青少年趣味编程
03-17 956
伸展树(Splay tree)图解与实现 伸展树(Splay tree)图解与实现_小张的专栏-CSDN博客_splay树 Splay树详解 Splay树详解 - 秦淮岸灯火阑珊 - 博客园 平衡树 之 Splay [知识点]平衡树之Splay_JK金坤_新浪博客 [Splay伸展树]splay树入门级教程 [Splay伸展树]splay树入门级教程_SKY的C-CSDN博客 查找——图文翔解SplayTree（伸展树） 查找——图文翔解SplayTree（伸展树）_..
运用伸展树解决数列维护问题 by Crash
06-14
实例分析部分提到了NOI 2005的题目“维护数列（Sequence）”，该题涉及在一个数列中频繁进行修改和查询操作。使用伸展树可以有效地解决这类问题，尽管伸展树在区间修改和查询方面比线段树稍显复杂，但它在某些特殊...
splay伸展树 指针型 平衡树基本操作 序列维护 详细讲解+总结
anantheparty的博客
12-21 3463
转载请保留本博客源地址：http://blog.csdn.net/u011327397/article/details/53783700 本来是要去学lct，然后看到要用splay我又不会，就开始看splay了，然后发现splay艹起来特别爽，但是序列操作网上没看到有详讲的，理解的时候很多奇怪的问题（无限RE）再加上指针调试复杂度高，花了很多时间，就觉得来写一个讲解吧。
sgu 187 Twist and whirl - want to cheat 伸展树(splay)
Broken Wings
12-02 1167
裸的区间翻转..直接写个splay就行，线段树应该也行吧..          #include #include #include #include #include #include #include using namespace std; const int maxn=130030; int pre[maxn],ch[maxn][2],size[maxn],key[max
hdu 4453 Looploop 伸展树splay
Broken Wings
10-03 1124
给一列数构成一个环，一个指针初始指向某个位置，两个参数k1,k2。有6种操作: add x 从指针指向位置开始，连续k2个数分别加上x；         reverse 从指针开始连续k1个数，反转位置.         insert  x 在指针指向位置的后面添加一个数x         delete  删除当前指针指向的数         move x  x==1时，指针前移
hdu 1890伸展树(splay tree)区间翻转
Broken Wings
09-20 989
一道用伸展树实现区间翻转的题..可能是第一次写翻转，明明是一道水题结果又搞了好久- -题意是给一串数，做n次操作，第i次操作选取区间 [a,b] 翻转，其中a为i，b为当前数组中第i小的数，并且输出翻转前第i小的数所在的位置。思路也比较好想，每个节点记录一个翻转标记flip，一个子节点数size，预先存好数组中第k大的数在原串中位置，建树时的下表就是这个位置数组（这个数组排个序，编个号就能求出来了
hdu3487 Play with Chain 伸展树splay
Broken Wings
10-08 912
一个长度为n的数列，初始状态为1,2...n。现有两种操作，CUT a,b,c 将从a开始到b结束这段数取出，并把这段插入到取出之后这个数列的第c个数后面；FLIP a,b 将从a开始到c结束的这段数颠倒顺序。 还是基本的splay操作，为了操作方便，先添加虚拟的头结点和尾节点，再把这串数插入到头尾之间。CUT操作就把a伸展到根，把b+2伸展到根的下面，这样b+2的左孩子就是目标段a+1,b+1了
BZOJ 1269 [AHOI2006]文本编辑器editor 伸展树splay
Broken Wings
10-09 871
题目也是中文的就不说题意了。新开一个变量pos记录光标在第pos个节点，因为头尾同样要虚拟一个头结点和尾结点，所以光标也就是指向当前序列的第pos-1个字符。move,prev,next直接修改pos的值就行，剩下的就都是伸展树的基本操作了。insert操作就把pos伸展到根，pos+1伸展到根的下边，向pos+1的左孩子循环添加节点就行，添加完记得自底而上pushup回来。rotate就把pos
poj 2761 Feed the dogs treap
Broken Wings
03-04 852
N个数，M个查询，每次查询L到R区间的第k小元素。可以用treap离线做..读取所有的查询，按左区间排序，由于数据保证不存在互相包涵的查询，所以相邻的两个区间要么相离，要么部分交叉。相离就依次删除上一次的元素，再一次插入本次的元素；交叉就删除上次不重叠的部分，然后把本次不重叠的部分插入。 #include #include #include #include #include usin
poj3580 SuperMemo 伸展树 splay
Broken Wings
10-14 833
依然是伸展树的基本操作，不过这次多了一个revolve x,y,z 选取x--y的子串，平移z位。也好处理，找到起点的新位置，然后把子串拆成两段，把后面的切下来插到前边就行了。要注意的一点就是z可能很大，也可能是负数....           #include #include #include #include #include #include #include #inc
伸展树：高效解决数列维护问题
文档中提到的实例分析NOI2005维护数列问题，通过伸展树可以实现快速的插入、删除和查询，同时减少不必要的计算。 对比线段树，伸展树在某些特定情况下可能具有更好的性能，尤其是在访问模式有明显热点时。然而，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值