hdu 3397 Sequence operation

题目大意：

给你一个0,1序列，有如下几种操作：

0 【a,b】：将a,b范围内都设置成0；

1 【a,b】：将a,b范围内都设置成1；

2 【a,b】：将a,b范围内0都设置成1,1设置成0，即进行区间异或；

3 【a,b】：求a,b范围内1的个数；

4 【a,b】：求a,b范围内最大的连续的1的个数；

解题思路：

区间修改，区间合并，2个懒惰标记，区间求和，这道题涉及的范围很广。

开始没有思路，后来看了网上大牛，自己写了一个代码，改了一天没有改对，后来做另外一道题的时候豁然开朗，哈哈，好开心；

ls，左连续1最长序列；rs右连续1最长序列，ms1区间最长连续序列

因为要进行反转，所以还要设定lo，ro，mo对应0序列，方便反转的处理；反转处理详见代码里的xor函数，就不说明了，其实很好推的，思考一下就行啦

首先应该注意pushup（）函数里对于区间最大连续1串的更新，左孩子的ms，右孩子ms，和左孩子的rs+右孩子ls的最大值；

pushdown（）的时候应该注意，如果有覆盖标记，则要把抑或标记置0；

xor函数的写法里要进行覆盖标记的判断，如果有覆盖标记，则要抑或一次该标记，没有的话直接抑或xr（抑或）标记即可；

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

#define maxn 100010
#define L(a) (a)<<1
#define R(a) (a)<<1|1

struct Node{
    int set,xr;
    int len;
    int sum;
    int lc,rc;
    int ls,rs,ms;
    int lo,ro,mo;
}node[3*maxn];

int cnt[maxn];
int cot;

void Xor(int k)
{
    swap(node[k].ls,node[k].lo);
    swap(node[k].rs,node[k].ro);
    swap(node[k].ms,node[k].mo);
    node[k].sum=node[k].len-node[k].sum;
    if(node[k].set!=-1)
    {
        node[k].set^=1;
    }
    else
    node[k].xr^=1;
}
void pushup(int k)
{
    node[k].ls=node[L(k)].ls;
    node[k].rs=node[R(k)].rs;
    
    node[k].lo=node[L(k)].lo;
    node[k].ro=node[R(k)].ro;
    
    node[k].sum=node[L(k)].sum+node[R(k)].sum;
    
    if(node[L(k)].ls==node[L(k)].len)
    node[k].ls+=node[R(k)].ls;
    if(node[R(k)].rs==node[R(k)].len)
    node[k].rs+=node[L(k)].rs;
    
    if(node[L(k)].lo==node[L(k)].len)
    node[k].lo+=node[R(k)].lo;
    if(node[R(k)].ro==node[R(k)].len)
    node[k].ro+=node[L(k)].ro;
    
    node[k].ms=max(node[R(k)].ms,node[L(k)].ms);
    node[k].mo=max(node[R(k)].mo,node[L(k)].mo);
    node[k].ms=max(node[k].ms,node[L(k)].rs+node[R(k)].ls);    
    node[k].mo=max(node[k].mo,node[L(k)].ro+node[R(k)].lo);
}

void pushdown(int k)
{
    if(node[k].set!=-1)
    {
        node[L(k)].set=node[R(k)].set=node[k].set;
        node[L(k)].xr=node[R(k)].xr=0;
        if(node[k].set==0)
        {
            node[L(k)].ls=node[L(k)].rs=node[L(k)].ms=node[L(k)].sum=0;
            node[L(k)].mo=node[L(k)].ro=node[L(k)].lo=node[L(k)].len;
            node[R(k)].ls=node[R(k)].rs=node[R(k)].ms=node[R(k)].sum=0;
            node[R(k)].mo=node[R(k)].ro=node[R(k)].lo=node[R(k)].len;
        }
        else if(node[k].set==1)
        {
            node[L(k)].ls=node[L(k)].rs=node[L(k)].ms=node[L(k)].sum=node[L(k)].len;
            node[L(k)].mo=node[L(k)].ro=node[L(k)].lo=0;
            node[R(k)].ls=node[R(k)].rs=node[R(k)].ms=node[R(k)].sum=node[R(k)].len;
            node[R(k)].mo=node[R(k)].ro=node[R(k)].lo=0;
        }
        node[k].set=-1;
    }
    if(node[k].xr)
    {   
        Xor(L(k));
        Xor(R(k));
        node[k].xr=0;
    }
}

void create(int k,int l,int r)
{
    node[k].set=-1;
    node[k].xr=0;
    node[k].len=r-l+1;
    node[k].lc=l;
    node[k].rc=r;
    if(l==r)
    {
        node[k].set=node[k].sum=node[k].ms=node[k].ls=node[k].rs=cnt[l];
        node[k].mo=node[k].lo=node[k].ro=(cnt[l]==0);
        return ;
    }
    int mid=(l+r)>>1;
    create(L(k),l,mid);
    create(R(k),mid+1,r);
    pushup(k);
}

void updata(int k,int l,int r,int op)
{
    
    if(node[k].lc>=l&&node[k].rc<=r)
    {
        if(op<2)
        {
            node[k].set=op;
            node[k].xr=0;
            node[k].sum=op?node[k].len:0;
            node[k].ls=node[k].rs=node[k].ms=op?node[k].len:0;
            node[k].lo=node[k].ro=node[k].mo=op?0:node[k].len;
            return ;
        }
        else if(op==2)
        {
            Xor(k);
            return ;
        }
    }
    else
    {
        pushdown(k);
        int mid=(node[k].lc+node[k].rc)>>1;
        if(l<=mid)
        updata(L(k),l,r,op);
        if(r>mid)
        updata(R(k),l,r,op);
        pushup(k);
    }
}

void querysum(int k,int l,int r)
{
    if(node[k].lc>=l&&node[k].rc<=r)
    {
        cot+=node[k].sum;
        return ;
    }
    pushdown(k);
    int mid=(node[k].lc+node[k].rc)>>1;
    if(r<=mid)
    querysum(L(k),l,r);
    else if(l>mid)
    querysum(R(k),l,r);
    else
    {
        querysum(L(k),l,mid);
        querysum(R(k),mid+1,r);
    }
}

int query(int k,int l,int r)
{
    if(node[k].lc>=l&&node[k].rc<=r)
    {
        return node[k].ms;
    }
    int mid=(node[k].lc+node[k].rc)>>1;
    pushdown(k);
    int ans=0;
    if(r<=mid)
    ans=max(ans,query(L(k),l,r));
    else if(l>mid)
    ans=max(ans,query(R(k),l,r));
    else
    {
        ans=max(ans,query(L(k),l,mid));
        ans=max(ans,query(R(k),mid+1,r));
    }
    ans=max(ans,min(node[L(k)].rs,mid-l+1)+min(node[R(k)].ls,r-mid));
    return ans;
}
int main()
{
    int t;
    //freopen("input.txt","r",stdin);
    scanf("%d",&t);
    int n,m;
    while(t--)
    {
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
        scanf("%d",&cnt[i]);
        create(1,1,n);
        int a,b,c;
        for(int i=0;i<m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(a<3)
            updata(1,b+1,c+1,a);
            else if(a==3)
            {
                cot=0;
                querysum(1,b+1,c+1);
                printf("%d\n",cot);
            } 
            else
            {
                int tt=query(1,b+1,c+1);
                printf("%d\n",tt);
            }
        }
    }
}