[题解]bzoj4592 SHOI2015脑洞治疗仪

Description

曾经发明了自动刷题机的发明家SHTSC又公开了他的新发明：脑洞治疗仪–一种可以治疗他因为发明而日益增大的脑洞的神秘装置。
为了简单起见，我们将大脑视作一个01序列。1代表这个位置的脑组织正常工作，0代表这是一块脑洞。
1 0 1 0 0 0 1 1 1 0
脑洞治疗仪修补某一块脑洞的基本工作原理就是将另一块连续区域挖出，将其中正常工作的脑组织填补在这块脑洞中。
（所以脑洞治疗仪是脑洞的治疗仪？）
例如，用上面第8号位置到第10号位置去修补第1号位置到第4号位置的脑洞。我们就会得到：
1 1 1 1 0 0 1 0 0 0
如果再用第1号位置到第4号位置去修补第8号位置到第10号位置：
0 0 0 0 0 0 1 1 1 1
这是因为脑洞治疗仪会把多余出来的脑组织直接扔掉。
如果再用第7号位置到第10号位置去填补第1号位置到第6号位置：
1 1 1 1 0 0 0 0 0 0
这是因为如果新脑洞挖出来的脑组织不够多，脑洞治疗仪仅会尽量填补位置比较靠前的脑洞。
假定初始时SHTSC并没有脑洞，给出一些挖脑洞和脑洞治疗的操作序列，你需要即时回答SHTSC的问题：
在大脑某个区间中最大的连续脑洞区域有多大。

Input

第一行两个整数n，m。表示SHTSC的大脑可分为从1到n编号的n个连续区域。有m个操作。
以下m行每行是下列三种格式之一。
0 l r ：SHTSC挖了一个从l到r的脑洞。
1 l0 r0 l1 r2 ：SHTSC进行了一次脑洞治疗，用从l0到r0的脑组织修补l1到r1的脑洞。
2 l r ：SHTSC询问l到r这段区间最大的脑洞有多大。
n,m <=200000，1<=l<=r<=n

Output

对于每个询问，输出一行一个整数，表示询问区间内最大连续脑洞区域有多大。
线段树维护区间信息：
区间从左开始连续的0个数
区间从右开始连续的0个数
区间连续0的最大长度
区间0的个数
区间长度
区间被0/1覆盖的标记
支持操作：
区间覆盖0/1
查询区间1的个数
查询区间最长的连续0的长度

Solution

线段树维护区间左右的连续0个数和区间内最大的连续0个数。
注意修补脑洞的时候如果左儿子能够放下就递归左儿子，否则直接覆盖左儿子，减去左儿子用掉的1的数量，递归右儿子。

代码：

#include<cstdio>
#include<algorithm>
using namespace std;

template<typename T>inline void read(T &x){
    T f=1;char ch=getchar();
    for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
    for(x=0;ch>='0'&&ch<='9';ch=getchar())x=x*10+ch-'0';
    x*=f;
}

const int maxn=200010;
struct Tag{
    int lmax,rmax,rng,L,R;
    Tag(){
        lmax=rmax=rng=L=R=0;
    }
    friend Tag operator+(Tag lc,Tag rc){
        Tag x;
        x.lmax=lc.lmax+(lc.lmax==(lc.R-lc.L+1)?rc.lmax:0);
        x.rmax=rc.rmax+(rc.rmax==(rc.R-rc.L+1)?lc.rmax:0);
        x.rng=max(max(lc.rng,rc.rng),lc.rmax+rc.lmax);
        x.L=lc.L;x.R=rc.R;
        return x;
    }
};
struct Segment_Tree{
    #define lc x<<1
    #define rc x<<1|1
    int L[maxn<<2],R[maxn<<2],k;
    int num[2][maxn<<2],same[maxn<<2];
    Tag tag[maxn<<2];
    void update(int x){
        num[0][x]=num[0][lc]+num[0][rc];
        num[1][x]=num[1][lc]+num[1][rc];
        tag[x]=tag[lc]+tag[rc];
    }
    void pushsame(int x,int t){
        num[t][x]=R[x]-L[x]+1;
        num[t^1][x]=0;same[x]=t;
        if(!t)tag[x].lmax=tag[x].rmax=tag[x].rng=num[0][x];
        else tag[x].lmax=tag[x].rmax=tag[x].rng=0;
    }
    void Build(int x,int l,int r){
        same[x]=-1;
        if((tag[x].L=L[x]=l)==(tag[x].R=R[x]=r)){
            pushsame(x,1);
            return;
        }
        int mid=(l+r)>>1;
        Build(lc,l,mid);Build(rc,mid+1,r);
        update(x);
    }
    void pushdown(int x){
        if(same[x]!=-1){
            pushsame(lc,same[x]);
            pushsame(rc,same[x]);
            same[x]=-1;
        }
    }
    void Modify(int x,int l,int r){
        if(L[x]>=l&&R[x]<=r)return pushsame(x,0),void();
        pushdown(x);
        int mid=(L[x]+R[x])>>1;
        if(l<=mid)Modify(lc,l,r);
        if(r>mid)Modify(rc,l,r);
        update(x);
    }
    void Treat(int x,int l,int r){
        if(!k||!num[0][x])return;
        if(L[x]>=l&&R[x]<=r){
            if(num[0][x]<=k)return k-=num[0][x],pushsame(x,1),void();
            pushdown(x);
            if(k>num[0][lc]){
                Treat(lc,l,r);
                Treat(rc,l,r);
            }
            else Treat(lc,l,r);
            update(x);
            return;
        }
        pushdown(x);
        int mid=(L[x]+R[x])>>1;
        if(l<=mid)Treat(lc,l,r);
        if(r>mid)Treat(rc,l,r);
        update(x);
    }
    int Query(int x,int l,int r,int t){
        if(L[x]>=l&&R[x]<=r)return num[t][x];
        pushdown(x);
        int mid=(L[x]+R[x])>>1,ans=0;
        if(l<=mid)ans+=Query(lc,l,r,t);
        if(r>mid)ans+=Query(rc,l,r,t);
        return ans;
    }
    Tag Query(int x,int l,int r){
        if(L[x]>=l&&R[x]<=r)return tag[x];
        pushdown(x);
        int mid=(L[x]+R[x])>>1;
        if(l<=mid&&r>mid)return Query(lc,l,r)+Query(rc,l,r);
        else if(l<=mid)return Query(lc,l,r);
        else return Query(rc,l,r);
    }
}tree;
int n,m;

int main(){
    read(n);read(m);
    tree.Build(1,1,n);
    while(m--){
        int opt,l0,r0,l1,r1,k;
        read(opt);read(l0);read(r0);
        if(!opt)tree.Modify(1,l0,r0);
        else if(opt==1){
            read(l1);read(r1);
            k=tree.Query(1,l0,r0,1);
            tree.Modify(1,l0,r0);
            tree.k=k;
            tree.Treat(1,l1,r1);
        }
        else{
            Tag temp=tree.Query(1,l0,r0);
            printf("%d\n",temp.rng);
        }
    }
    return 0;
}