码风良好，求调

#include <bits/stdc++.h>
using namespace std;
#define ls k<<1
#define rs k<<1|1
const int N = 4e5+10;
int n, m;
int a[N];
struct Node{
    int sum1, sum0, sumc1, sumc0, l1, r1, l0, r0, len;
    int tag1, tag0, tagu;
}f[N];
void push_up(int k)
{
    if(f[ls].l1==f[ls].len) f[k].l1 = f[ls].l1+f[rs].l1;
    else f[k].l1 = f[ls].l1;
    if(f[rs].r1==f[rs].len) f[k].r1 = f[rs].r1+f[ls].r1;
    else f[k].r1 = f[rs].r1;

    if(f[ls].l0==f[ls].len) f[k].l0 = f[ls].l0+f[rs].l0;
    else f[k].l0 = f[ls].l0;
    if(f[rs].r0==f[rs].len) f[k].r0 = f[ls].r0+f[rs].r0;
    else f[k].r0 = f[rs].r0;

    f[k].sum0 = f[ls].sum0+f[rs].sum0;
    f[k].sum1 = f[ls].sum1+f[rs].sum1;
    f[k].sumc0 = max(max(f[k].l0, f[k].r0), max(f[ls].sumc0, f[rs].sumc0));
    f[k].sumc1 = max(max(f[k].l1, f[k].r1), max(f[ls].sumc1, f[rs].sumc1));
}
void build(int k, int l, int r)
{
    if(l==r)
    {
        f[k].sum1 = f[k].sumc1 = f[k].l1 = f[k].r1 = a[l];
        f[k].sum0 = f[k].sumc0 = f[k].l0 = f[k].r0 = !a[l];
        f[k].len = 1;
        return;
    }
    int mid = l+r>>1;
    build(ls, l, mid);
    build(rs, mid+1, r);
    f[k].len = f[ls].len+f[rs].len;
    push_up(k);
}
void push_down(int k)
{
    if(f[k].tagu)
    {
        swap(f[ls].l0, f[ls].l1);
        swap(f[ls].r0, f[ls].r1);
        swap(f[ls].sum1, f[ls].sum0); 
        swap(f[ls].sumc1, f[ls].sumc0);

        swap(f[rs].l0, f[rs].l1);
        swap(f[rs].r0, f[rs].r1);
        swap(f[rs].sum1, f[rs].sum0);
        swap(f[rs].sumc1, f[rs].sumc0);

        if(f[ls].tag1) f[ls].tag1 = 0, f[ls].tag0 = 1, f[ls].tagu = 0;
        else if(f[ls].tag0) f[ls].tag1 = 1, f[ls].tag0 = 0, f[ls].tagu = 0;
        else f[ls].tagu = !f[ls].tagu;

        if(f[rs].tag1) f[rs].tag1 = 0, f[rs].tag0 = 1, f[rs].tagu = 0;
        else if(f[rs].tag0) f[rs].tag1 = 1, f[rs].tag0 = 0, f[rs].tagu = 0;
        else f[rs].tagu = !f[rs].tagu;
        f[k].tagu = 0;
    }
    if(f[k].tag1)
    {
        f[ls].sum1 = f[ls].l1 = f[ls].r1 = f[ls].sumc1 = f[ls].len;
        f[rs].sum1 = f[rs].l1 = f[rs].r1 = f[rs].sumc1 = f[rs].len;
        f[ls].sum0 = f[ls].l0 = f[ls].r0 = f[ls].sumc0 = 0;
        f[rs].sum0 = f[rs].l0 = f[rs].r0 = f[rs].sumc0 = 0;
        f[ls].tag1 = f[rs].tag1 = 1;
        f[ls].tag0 = f[rs].tag0 = f[ls].tagu = f[rs].tagu = 0;
        f[k].tag1 = 0;
    }
    if(f[k].tag0)
    {
        f[ls].sum1 = f[ls].l1 = f[ls].r1 = f[ls].sumc1 = 0;
        f[rs].sum1 = f[rs].l1 = f[rs].r1 = f[rs].sumc1 = 0;
        f[ls].sum0 = f[ls].l0 = f[ls].r0 = f[ls].sumc0 = f[ls].len;
        f[rs].sum0 = f[rs].l0 = f[rs].r0 = f[rs].sumc0 = f[rs].len;
        f[ls].tag0 = f[rs].tag0 = 1;
        f[ls].tag1 = f[rs].tag1 = f[ls].tagu = f[rs].tagu = 0;
        f[k].tag0 = 0;
    }
}
void update(int k, int l, int r ,int x, int y, int v)
{
    if(l>=x&&r<=y)
    {
        if(v==1)
        {
            f[k].sum1 = f[k].sumc1 = f[k].l1 = f[k].r1 = f[k].len;
            f[k].sum0 = f[k].sumc0 = f[k].l0 = f[k].r0 = 0;
            f[k].tag1 = 1, f[k].tag0 = f[k].tagu = 0;
        }
        else if(!v)
        {
            f[k].sum1 = f[k].sumc1 = f[k].l1 = f[k].r1 = 0;
            f[k].sum0 = f[k].sumc0 = f[k].l0 = f[k].r0 = f[k].len;
            f[k].tag0 = 1, f[k].tag1 = f[k].tagu = 0;
        }
        else if(v==2)
        {
            swap(f[k].sum1, f[k].sum0);
            swap(f[k].l0, f[k].l1);
            swap(f[k].r0, f[k].r1);
            swap(f[k].sumc1, f[k].sumc0);

            if(f[k].tag1) f[k].tag1 = 0, f[k].tag0 = 1, f[k].tagu = 0;
            else if(f[k].tag0) f[k].tag0 = 0, f[k].tag1 = 1, f[k].tagu = 0;
            else f[k].tagu = !f[k].tagu;
        }
        return;
    }
    push_down(k);
    int mid = l+r>>1;
    if(mid>=x) update(ls, l, mid, x, y, v);
    if(mid<y) update(rs, mid+1, r , x, y, v);
    push_up(k);
}
Node query(int k, int l, int r, int x, int y)
{
    if(x<=l&&r<=y) return f[k];
    push_down(k);
    int mid = l+r>>1;
    if(mid>=y) return query(ls, l, mid, x, y);
    else if(mid<x) return query(rs, mid+1, r, x, y);
    else
    {
        Node xa = query(ls, l, mid, x, y), xb = query(rs, mid+1, r, x, y);
        Node res;
        if(xa.l1==xa.len) res.l1 = xa.l1+xb.l1;
        else res.l1 = xa.l1;
        if(xb.r1==xb.len) res.r1 = xb.r1+xa.r1;
        else res.r1 = xb.r1;
        res.len = xa.len+xb.len;
        res.sumc1 = max(max(xa.sumc1, xb.sumc1), max(res.l1, res.r1));
        res.sum1 = xa.sum1+xb.sum1; 
        return res;
    }                    
}
int main()
{
    cin >> n >> m;
    for(int i=1;i<=n;i++) cin >> a[i];
    build(1, 1, n);
    for(int i=1;i<=m;i++)
    {
        int x, y, z;
        cin >> x >> y >> z;
        ++y, ++z;
        if(!x) update(1, 1, n, y, z, 0);
        else if(x==1) update(1, 1, n, y, z, 1);
        else if(x==2) update(1, 1, n, y, z, 2);
        else if(x==3) cout << query(1, 1, n, y, z).sum1 << endl;
        else cout << query(1, 1, n, y, z).sumc1 << endl;
    }
    return 0;
}

全WA，只过了Subtask #1