30pts wa on #4~10 求助悬关

#include <bits/stdc++.h>
using namespace std;
#define N 100005

int n,q;
struct node
{
    int l,r,flag1,flag2,flag3,sum,lmax0,lmax1,rmax0,rmax1,max0,max1;
}t[N*4];

void pushup(int p,int l,int r)
{
    t[p].sum=t[l].sum+t[r].sum;

    if(t[l].lmax0==t[l].r-t[l].l+1)
        t[p].lmax0=t[l].lmax0+t[r].lmax0;
    else
        t[p].lmax0=t[l].lmax0;

    if(t[l].lmax1==t[l].r-t[l].l+1)
        t[p].lmax1=t[l].lmax1+t[r].lmax1;
    else
        t[p].lmax1=t[l].lmax1;

    if(t[r].rmax0==t[r].r-t[r].l+1)
        t[p].rmax0=t[r].rmax0+t[l].rmax0;
    else
        t[p].rmax0=t[r].rmax0;

    if(t[r].rmax1==t[r].r-t[r].l+1)
        t[p].rmax1=t[r].rmax1+t[l].rmax1;
    else
        t[p].rmax1=t[r].rmax1;

    t[p].max0=max(t[l].max0,t[r].max0);
    t[p].max0=max(t[p].max0,t[l].rmax0+t[r].lmax0);

    t[p].max1=max(t[l].max1,t[r].max1);
    t[p].max1=max(t[p].max1,t[l].rmax1+t[r].lmax1);
}

void pushdown1(int p,int l,int r)
{
    if(t[p].flag1)
    {
        t[l].flag2=0;
        t[r].flag2=0;

        t[l].flag3=0;
        t[r].flag3=0;

        t[l].flag1=1-t[l].flag1;
        t[r].flag1=1-t[r].flag1;

        t[l].sum=t[r].sum=0;

        t[l].lmax0=t[l].r-t[l].l+1;
        t[r].lmax0=t[r].r-t[r].l+1;
        t[l].lmax1=t[r].lmax1=0;

        t[l].rmax0=t[l].r-t[l].l+1;
        t[r].rmax0=t[r].r-t[r].l+1;
        t[l].rmax1=t[r].rmax1=0;

        t[l].max0=t[l].r-t[l].l+1;
        t[r].max0=t[r].r-t[r].l+1;
        t[l].max1=t[r].max1=0;

        t[p].flag1=0;
    }
}

void pushdown2(int p,int l,int r)
{
    if(t[p].flag2)
    {
        t[l].flag1=0;
        t[r].flag1=0;

        t[l].flag3=0;
        t[r].flag3=0;

        t[l].flag2=1-t[l].flag2;
        t[r].flag2=1-t[r].flag2;

        t[l].sum=t[l].r-t[l].l+1;
        t[r].sum=t[r].r-t[r].l+1;

        t[l].lmax0=t[r].lmax0=0;
        t[l].lmax1=t[l].r-t[l].l+1;
        t[r].lmax1=t[r].r-t[r].l+1; 

        t[l].rmax0=t[r].rmax0=0;
        t[l].rmax1=t[l].r-t[l].l+1;
        t[r].rmax1=t[r].r-t[r].l+1;

        t[l].max0=t[r].max0=0;
        t[l].max1=t[l].r-t[l].l+1;
        t[r].max1=t[r].r-t[r].l+1;

        t[p].flag2=0;
    }
}

void pushdown3(int p,int l,int r)
{
    if(t[p].flag3)
    {
        t[l].flag3=1-t[l].flag3;
        t[r].flag3=1-t[r].flag3;

        t[l].sum=t[l].r-t[l].l+1-t[l].sum;
        t[r].sum=t[r].r-t[r].l+1-t[r].sum;

        swap(t[l].lmax0,t[l].lmax1);
        swap(t[r].lmax0,t[r].lmax1);

        swap(t[l].rmax0,t[l].rmax1);
        swap(t[r].rmax0,t[r].rmax1);

        swap(t[l].max0,t[l].max1);
        swap(t[r].max0,t[r].max1);

        t[p].flag3=0;
    }
}

void pushdown(int p)
{
    pushdown1(p,p*2,p*2+1);
    pushdown2(p,p*2,p*2+1);
    pushdown3(p,p*2,p*2+1);
}

void build(int p,int l,int r)
{
    t[p].l=l;
    t[p].r=r;

    if(l==r)
    {
        scanf("%d",&t[p].sum);
        if(t[p].sum)
            t[p].lmax1=t[p].rmax1=t[p].max1=1;  
        else
            t[p].lmax0=t[p].rmax0=t[p].max0=1;
        return;
    }

    int mid=(l+r)>>1;
    build(p*2,l,mid);
    build(p*2+1,mid+1,r);

    pushup(p,p*2,p*2+1);
}

void change1(int p,int l,int r)
{
    if(t[p].l>=l && t[p].r<=r)
    {
        t[p].flag2=0;
        t[p].flag3=0;
        t[p].flag1=1-t[p].flag1;

        t[p].sum=0;

        t[p].lmax0=t[p].rmax0=t[p].max0=t[p].r-t[p].l+1;
        t[p].lmax1=t[p].rmax1=t[p].max1=0;

        return;
    }

    pushdown(p);

    int mid=(t[p].l+t[p].r)>>1;
    if(mid>=l)
        change1(p*2,l,r);
    if(mid<r)
        change1(p*2+1,l,r);

    pushup(p,p*2,p*2+1);
}

void change2(int p,int l,int r)
{
    if(t[p].l>=l && t[p].r<=r)
    {
        t[p].flag1=0;
        t[p].flag3=0;
        t[p].flag2=1-t[p].flag2;

        t[p].sum=t[p].r-t[p].l+1;

        t[p].lmax0=t[p].rmax0=t[p].max0=0;
        t[p].lmax1=t[p].rmax1=t[p].max1=t[p].r-t[p].l+1;

        return;
    }

    pushdown(p);

    int mid=(t[p].l+t[p].r)>>1;
    if(mid>=l)
        change2(p*2,l,r);
    if(mid<r)
        change2(p*2+1,l,r);

    pushup(p,p*2,p*2+1);
}

void change3(int p,int l,int r)
{
    if(t[p].l>=l && t[p].r<=r)
    {
        t[p].flag3=1-t[p].flag3;

        t[p].sum=t[p].r-t[p].l+1-t[p].sum;

        swap(t[p].lmax0,t[p].lmax1);
        swap(t[p].rmax0,t[p].rmax1);
        swap(t[p].max0,t[p].max1);

        return;
    }

    pushdown(p);

    int mid=(t[p].l+t[p].r)>>1;
    if(mid>=l)
        change3(p*2,l,r);
    if(mid<r)
        change3(p*2+1,l,r);

    pushup(p,p*2,p*2+1);
}

int query1(int p,int l,int r)
{
    if(t[p].l>=l && t[p].r<=r)
        return t[p].sum;

    pushdown(p);

    int mid=(t[p].l+t[p].r)>>1,sum=0;
    if(mid>=l)
        sum+=query1(p*2,l,r);
    if(mid<r)
        sum+=query1(p*2+1,l,r);

    return sum;
}

 node query2(int p,int l,int r)
 {
    if(t[p].l>=l && t[p].r<=r)
        return t[p];

    pushdown(p);

    int mid=(t[p].l+t[p].r)>>1;
    if(mid>=r)
        return query2(p*2,l,r);
    else if(mid<l)
        return query2(p*2+1,l,r);

    else
    {
        node ans1=query2(p*2,l,r);
        node ans2=query2(p*2+1,l,r);
        node ans3;

        if(ans1.lmax0==ans1.r-ans1.l+1)
            ans3.lmax0=ans1.lmax0+ans2.lmax0;
        else
            ans3.lmax0=ans1.lmax0;

        if(ans1.lmax1==ans1.r-ans1.l+1)
            ans3.lmax1=ans1.lmax1+ans2.lmax1;
        else
            ans3.lmax1=ans1.lmax1;

        if(ans2.rmax0==ans2.r-ans2.l+1)
            ans3.rmax0=ans2.rmax0+ans1.rmax0;
        else
            ans3.rmax0=ans2.rmax0;

        if(ans2.rmax1==ans2.r-ans2.l+1)
            ans3.rmax1=ans2.rmax1+ans1.rmax1;
        else
            ans3.rmax1=ans2.rmax1;

        ans3.max0=max(ans1.max0,ans2.max0);
        ans3.max0=max(ans3.max0,ans1.rmax0+ans2.lmax0);

        ans3.max1=max(ans1.max1,ans2.max1);
        ans3.max1=max(ans3.max1,ans1.rmax1+ans2.lmax1);

        return ans3;
    }
 }

int main( void )
{
    scanf("%d%d",&n,&q);
    build(1,1,n);

    while(q--)
    {
        int opt,l,r;
        scanf("%d%d%d",&opt,&l,&r);
        l++;r++; 

        if(opt==0)
            change1(1,l,r);

        else if(opt==1)
            change2(1,l,r);

        else if(opt==2)
            change3(1,l,r);

        else if(opt==3)
            printf("%d\n",query1(1,l,r));

        else
            printf("%d\n",query2(1,l,r).max1);
    }

    return 0;
}