BZOJ 3223 文艺平衡树 [codevs3303翻转区间]

AC通道:http://www.lydsy.com/JudgeOnline/problem.php?id=3223

通道2:http://codevs.cn/problem/3303/

 

题目分析:

我们先想想数组怎么操作。

每次O(1)找到区间位置,然后旋转,大概是O(r-l+1)的。

这样太慢了,每次我都将操作进行到底了。可是翻转标记有时候其实不需要每个都去办,因为它们之间还可以互相抵消。

能不能用线段树呢?

找到区间log(n),标记一下O(1),可以过?

不行!这个翻转显得与往常处理的线段树题目不一样,因为之前线段树是静态的数轴,但是这个数轴会翻转!

直接根据下标找到的只是数值,不是现在它在数组中的位置。每次怎么找到新的区间位置?

每次去找的时候,将标记下传然后翻转线段树[交换左右节点]好像就行了...

线段树真的可以翻转么?我每个节点的信息岂不是非常混乱!下次再想找到这个区间就不容易了,因为我线段树的数值不满足当初的性质了。

 

通过刚才的分析,发现这题中的数值其实没有多大作用,只是它特殊的一个标记而已,重要的还是它在序列中的位置,以及如何处理好翻转与查询的关系。

翻转是不能彻底进行的,要用标记且标记不能下传到底,但是在这样的条件下要有一种快速的算法,让我们找到我们需要的区间。

标记让人想到树结构,快速找区间又想到二叉树,于是不妨维护一颗搜索二叉树,其中以这个元素在序列中的位置作为排序的标准。

 

在每次寻找左右端点时,即使有一些节点的标记还未下传,但是只要这个节点下的子树的元素个数小于当前我的查询值,我就可以跳过它。

反之,就将它的标记下传,并让它的左右子树交换位置,依次往下,直到找到自己需要的那个节点上。

 

节点到区间的转变怎么实现呢?这边需要Splay()操作了。

首先将l-1转到根节点上来,然后将r+1转到l-1的右节点上。

这样[l,r]就很清晰而且全部存在于一棵子树下了。

 

有没有觉得这个算法的神奇之处啊?或是说Splay()也可以这样用,标记也可以这样用...Orz

当然这题还有几个地方需要注意,一是当l=1时,需要将排行第0的节点转上来(如果是n的话,你多虚拟一个n+1的节点是可以的)...不可实现啊,

【其实你也可以特判掉,在这种情况下只找r+1翻到顶上(对于n也可以这样特判)】,不过...笔者表示膜别人思路将所有节点的下标前移了一个,所以代码中表现的是将l和r+2进行操作。

二是刚开始建树的话,不仅要注意建到n+2【如果采用特判则是n+1】,也要尽量让它初始就平衡一点哦...

 

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

inline int in(){
    int x=0;char ch=getchar();
    while(ch>'9' || ch<'0') ch=getchar();
    while(ch>='0' && ch<='9') x=x*10+ch-'0',ch=getchar();
    return x;
}

const int maxn=100010;

int n,m,rt;

struct Node{
    int sz,f;
    int l,r;
    bool mk;
    
    void trans(){swap(l,r);}
}s[maxn];

inline void updata(int x){
    s[x].sz=s[s[x].l].sz+s[s[x].r].sz+1;
}

int build(int l,int r){
    if(l>r) return 0;
    int mid=(l+r)>>1;
    s[mid].l=build(l,mid-1);
    s[mid].r=build(mid+1,r);
    updata(mid);
    s[s[mid].l].f=mid,s[s[mid].r].f=mid;
    return mid;
}

inline void push_down(int x){
    if(s[x].mk){
        s[x].trans();
        s[s[x].l].mk^=1;
        s[s[x].r].mk^=1;
        s[x].mk=0;
    }
}

void zig(int x){
    int y=s[x].f;
    
    s[x].f=s[y].f;
    if(s[y].f){    
        if(y==s[s[y].f].l) s[s[y].f].l=x;
        else s[s[y].f].r=x;
    }
    
    s[y].l=s[x].r;
    if(s[x].r)
        s[s[x].r].f=y;
    
    s[y].f=x,s[x].r=y;
    
    updata(y);updata(x);
}

void zag(int x){
    int y=s[x].f;
    
    s[x].f=s[y].f;
    if(s[y].f){    
        if(y==s[s[y].f].l) s[s[y].f].l=x;
        else s[s[y].f].r=x;
    }
    
    s[y].r=s[x].l;
    if(s[x].l)
        s[s[x].l].f=y;
    
    s[x].l=y,s[y].f=x;
    
    updata(y);updata(x);
}

void Splay(int x,int gf){
    int y;
    while(s[x].f!=gf){
        y=s[x].f;
        if(s[y].f==gf){
            if(x==(s[y].l)) zig(x);
            else zag(x);
        }
        else{
            int z=s[y].f;
            if(y==s[z].l){
                if(x==s[y].l) zig(y),zig(x);
                else zag(x),zig(x);
            }
            else{
                if(x==s[y].r) zag(y),zag(x);
                else zig(x),zag(x);
            }
        }
    }
    if(!gf) rt=x;
}

int find(int k){
    int p=rt;
    if(k>s[p].sz) return 0;
    while(p){
        push_down(p);//每访问到一个节点,就将它的标记下传,从这个点到根的路上就都传完了
        if(k<=s[s[p].l].sz) p=s[p].l;
        else{
            k-=s[s[p].l].sz;
            if(k==1) return p;
            k--,p=s[p].r;
        }
    }
}

void rev(int l,int r){
    int a=find(l),b=find(r+2);//这里是找到这两个需要翻转的节点的位置
    Splay(a,0);Splay(b,a);
    s[s[b].l].mk^=1;
}

void print(int x){
    if(!x) return;
    push_down(x);
    print(s[x].l);
    if(x>1 && x<=n+1) //有几个节点是根据需要虚拟出的,它们不能输出
        printf("%d ",x-1);
    print(s[x].r);
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("3223.in","r",stdin);
    freopen("3223.out","w",stdout);
#endif
    
    int l,r;
    
    n=in();m=in();
    rt=build(1,n+2);
    while(m--)
        l=in(),r=in(),rev(l,r);
    print(rt);
    return 0;
}
View Code

 

posted @ 2015-12-22 16:58  诚叙  阅读(305)  评论(0编辑  收藏  举报