HDU 3397 Sequence operation

一道很好的线段树的题目，其实是我在给大家拉题目的时候拉错的。。。简直逗的不行。。。

这道题目对序列大概有下面几个操作：

set 操作，就是把区间里的所有数变成0或1

转置操作：把一个区间里的数从0变成1，从1变成0

查询1操作：返回一个区间里1的个数

查询2操作：返回一个区间中最长的1的长度

如果割裂来看的话每个操作都很容易实现，set操作和转置操作可以用lazy操作实现（你如果不用lazy，直接更新到底的话，应该是会T掉的），查询1操作可以用维护区间的和来实现（说到这里我觉得我实在是很逗啊，一开始我把转置操作理解成把和加上区间长度，最后查询的时候取余，但是这里是有问题的，比如你全是0和全是1就是完全一样了），查询2操作可以通过维护三个值来达到，从左边开始的最长串，从右边开始的最长串，整个区间的最长串。

这题思考到这里，想好了维护操作的时候就会有最重要的问题来了。就是转置操作和set操作到底改如何叠加？

首先，我们能想到的是，set操作应该是能覆盖转置操作的。

所以如果一个区间已经有转置操作，可以把这个标记直接摸成set操作，然后更新每个节点的值。

但这题最重要的是，如果要对一个区间进行转置操作的时候应该怎么办？

该题目的关键来了，如果该区间没有标记，则直接更改标记，再修改区间的各个值。

如果该区间有set为0的标记，则将该区间的标记改为1，并更新值

如果有set为1的标记，将标记改称0，更新值

如果有转置标记，将转置标记抹掉，并更新值。

代码写得有点丑。。。

#include "cstdio"
#include "cstring"
#include "iostream"
using namespace std;

#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

#define maxn 100005

int a[maxn];

int sum[maxn<<2];

int lazy[maxn<<2];

int l0[maxn<<2],m0[maxn<<2],r0[maxn<<2];
int l1[maxn<<2],m1[maxn<<2],r1[maxn<<2];

void maintain(int l,int r,int rt){
    int left=rt<<1, right=rt<<1|1;
    int m=(l+r)>>1;
    l0[rt]=l0[left],r0[rt]=r0[right];
    m0[rt]=max(m0[left],max(m0[right],r0[left]+l0[right]));
    if(l0[left]==(m-l+1))  l0[rt]=l0[left]+l0[right];
    if(r0[right]==(r-m))  r0[rt]=r0[left]+r0[right];
    m0[rt]=max(m0[rt],max(l0[rt],r0[rt]));
    
    l1[rt]=l1[left],r1[rt]=r1[right];
    m1[rt]=max(m1[left],max(m1[right],r1[left]+l1[right]));
    if(l1[left]==(m-l+1))  l1[rt]=l1[left]+l1[right];
    if(r1[right]==(r-m))  r1[rt]=r1[left]+r1[right];
    m1[rt]=max(m1[rt],max(l1[rt],r1[rt]));
}

void pushdown(int l,int r,int rt){
    int ll=rt<<1,rr=rt<<1|1;
    int m=(l+r)>>1;
    if(lazy[rt]==0){
        lazy[ll]=lazy[rr]=0;
        sum[ll]=sum[rr]=0;
        l0[ll]=m0[ll]=r0[ll]=m-l+1;
        l0[rr]=m0[rr]=r0[rr]=r-m;
        l1[ll]=m1[ll]=r1[ll]=l1[rr]=m1[rr]=r1[rr]=0;
        lazy[rt]=-1;
    }
    if(lazy[rt]==1){
        lazy[ll]=lazy[rr]=1;
        sum[ll]=m-l+1,sum[rr]=r-m;
        l1[ll]=m1[ll]=r1[ll]=m-l+1;
        l1[rr]=m1[rr]=r1[rr]=r-m;
        l0[ll]=m0[ll]=r0[ll]=l0[rr]=m0[rr]=r0[rr]=0;
        lazy[rt]=-1;
    }
    if(lazy[rt]==2){
        sum[ll]=m-l+1-sum[ll],sum[rr]=r-m-sum[rr];
        swap(l0[ll],l1[ll]),swap(m0[ll],m1[ll]),swap(r0[ll],r1[ll]);
        swap(l0[rr],l1[rr]),swap(m0[rr],m1[rr]),swap(r0[rr],r1[rr]);
        if(lazy[ll]==2)  lazy[ll]=-1;
        else  if(lazy[ll]==0)  lazy[ll]=1;
        else  if(lazy[ll]==1)  lazy[ll]=0;
        else  lazy[ll]=2;
        if(lazy[rr]==2)  lazy[rr]=-1;
        else  if(lazy[rr]==0)  lazy[rr]=1;
        else  if(lazy[rr]==1)  lazy[rr]=0;
        else  lazy[rr]=2;
        lazy[rt]=-1;
    }
    return;
}

void build(int l,int r,int rt){
    lazy[rt]=-1;
    if(l==r){
        sum[rt]=a[l];
        l0[rt]=m0[rt]=r0[rt]=a[l]? 0:1;
        l1[rt]=m1[rt]=r1[rt]=a[l]? 1:0;
        return;
    }
    int m=(l+r)>>1;
    build(lson);
    build(rson);
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
    maintain(l,r,rt);
}

void update(int L,int R,int op,int l,int r,int rt){
    if(L<=l&&R>=r){
        if(op==0){
            lazy[rt]=0;
            sum[rt]=0;
            l0[rt]=r0[rt]=m0[rt]=r-l+1;
            l1[rt]=r1[rt]=m1[rt]=0;
        }
        if(op==1){
            lazy[rt]=1;
            sum[rt]=r-l+1;
            l0[rt]=r0[rt]=m0[rt]=0;
            l1[rt]=r1[rt]=m1[rt]=r-l+1;
        }
        if(op==2){
            sum[rt]=r-l+1-sum[rt];
            swap(l0[rt],l1[rt]),swap(m0[rt],m1[rt]),swap(r0[rt],r1[rt]);
            if(lazy[rt]==2)  lazy[rt]=-1;
            else  if(lazy[rt]==0)  lazy[rt]=1;
            else  if(lazy[rt]==1)  lazy[rt]=0;
            else  lazy[rt]=2;
        }
        return;
    }
    int m=(l+r)>>1;
    pushdown(l,r,rt);
    if(L<=m)  update(L,R,op,lson);
    if(R>m)  update(L,R,op,rson);
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
    maintain(l,r,rt);
}

int query(int L,int R,int op,int l,int r,int rt){
    int m=(l+r)>>1;
    if(op==3){
        if(L<=l&&R>=r){
            return sum[rt];
        }
        pushdown(l,r,rt);
        int ans=0;
        if(L<=m)  ans+=query(L,R,op,lson);
        if(R>m)  ans+=query(L,R,op,rson);
        return ans;
    }else{
        if(L<=l&&R>=r){
            return m1[rt];
        }
        pushdown(l,r,rt);
        int ans=0;
        if(L<=m)  ans=max(ans,query(L,R,op,lson));
        if(R>m)  ans=max(ans,query(L,R,op,rson));
        ans=max(ans,min(m-L+1,r1[rt<<1])+min(R-m,l1[rt<<1|1]));
        return ans;
    }
}

int main(){
    int T;
    int n,m;
    int op,p,q;
    scanf("%d",&T);
    while(T--){
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)  scanf("%d",&a[i]);
        build(1,n,1);
        while(m--){
            scanf("%d%d%d",&op,&p,&q);
            if(op<3)  update(p+1,q+1,op,1,n,1);
            else  printf("%d\n",query(p+1,q+1,op,1,n,1));
        }
    }
    return 0;
}