10分求dalao调

#include<bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m;
int a[N];

struct tree{
    int len;
    int l, r;
    int t1, t2;//t1修改, t2取反 
    int s0, s1;
    int m0, m1, l0, r0, l1, r1;
};
tree t[N * 4];

void push_up(int x){
    tree l = t[x * 2], r = t[x * 2 + 1];
    t[x].len = l.len + r.len;
    t[x].s0 = l.s0 + r.s0;
    t[x].s1 = l.s1 + r.s1;
    t[x].l1 = l.s0 ? l.l1 : l.s1 + r.l1;
    t[x].r1 = r.s0 ? r.r1 : r.s1 + l.r1;
    t[x].l0 = l.s1 ? l.l0 : l.s0 + r.l0;
    t[x].r0 = r.s1 ? r.r0 : r.s0 + l.r0;
    t[x].m1 = max(l.l1, max(l.r1 + r.l1, r.r1));
    t[x].m0 = max(l.l0, max(l.r0 + r.l0, r.r0));
}

void push_down(int x){
    int l = x * 2, r = x * 2 + 1;
    if(t[x].t1 == 0){
        t[l].t1 = t[r].t1 = 0;
        t[l].s1 = t[l].m1 = t[l].r1 = t[l].l1 = t[r].s1 = t[r].m1 = t[r].r1 = t[r].l1 = 0;
        t[l].s0 = t[l].m0 = t[l].l0 = t[l].r0 = t[l].len;
        t[r].s0 = t[r].m0 = t[r].l0 = t[r].r0 = t[r].len;
        t[l].t2 = t[r].t2 = 0;
    }
    if(t[x].t1 == 1){
        t[l].t1 = t[r].t1 = 1;
        t[l].s0 = t[l].m0 = t[l].r0 = t[l].l0 = t[r].s0 = t[r].m0 = t[r].r0 = t[r].l0 = 0;
        t[l].s1 = t[l].m1 = t[l].l1 = t[l].r1 = t[l].len;
        t[r].s1 = t[r].m1 = t[r].l1 = t[r].r1 = t[r].len;
        t[l].t2 = t[r].t2 = 0;
    }
    if(t[x].t2 == 1){
        t[l].t2 ^= 1;
        t[r].t2 ^= 1;
        swap(t[l].s1, t[l].s0);
        swap(t[l].m1, t[l].m0);
        swap(t[l].l1, t[l].l0);
        swap(t[l].r1, t[l].r0);
        swap(t[r].s1, t[r].s0);
        swap(t[r].m1, t[r].m0);
        swap(t[r].l1, t[r].l0);
        swap(t[r].r1, t[r].r0);
    }
    t[x].t1 = -1;
    t[x].t2 = 0;
}

void build(int x, int l, int r){
    t[x].l = l, t[x].r = r;
    t[x].t1 = -1;
    if(l == r){
        t[x].len = 1;
        t[x].m1 = t[x].s1 = t[x].l1 = t[x].r1 = a[l];
        t[x].m0 = t[x].s0 = t[x].l0 = t[x].r0 = !a[l];
        return;
    }
    int mid = l + r >> 1;
    build(x * 2, l, mid);
    build(x * 2 + 1, mid + 1, r);
    push_up(x);
}

void update(int x, int l, int r, int op){
    if(t[x].l >= l && t[x].r <= r){
        if(op == 0){
            t[x].t2 = 0;
            t[x].t1 = 0;
            t[x].s1 = t[x].m1 = t[x].r1 = t[x].l1 = 0;
            t[x].s0 = t[x].m0 = t[x].l0 = t[x].r0 = t[x].len;
        }else if(op == 1){
            t[x].t2 = 0;
            t[x].t1 = 1;
            t[x].s1 = t[x].m1 = t[x].r1 = t[x].l1 = t[x].len;
            t[x].s0 = t[x].m0 = t[x].l0 = t[x].r0 = 0;
        }else{
            t[x].t2 ^= 1;
            swap(t[x].s1, t[x].s0);
            swap(t[x].m1, t[x].m0);
            swap(t[x].l1, t[x].l0);
            swap(t[x].r1, t[x].r0);
        }
        return;
    }
    push_down(x);
    int mid = t[x].l + t[x].r >> 1;
    if(l <= mid) update(x * 2, l, r, op);
    if(r > mid) update(x * 2 + 1, l, r, op);
    push_up(x);
}

int query1(int x, int l, int r){
    if(t[x].l >= l && t[x].r <= r){
        return t[x].s1;
    }
    push_down(x);
    int mid = t[x].l + t[x].r >> 1, ans = 0;
    if(l <= mid) ans += query1(x * 2, l, r);
    if(r > mid) ans += query1(x * 2 + 1, l, r);
    return ans;
}

tree query2(int x, int l, int r){
    if(t[x].l >= l && t[x].r <= r){
        return t[x];
    }
    int mid = t[x].l + t[x].r >> 1;
    push_down(x); 
    if(r <= mid) return query2(x * 2, l, r);
    else if(l > mid) return query2(x * 2 + 1, l, r);
    else{
        tree ans, a = query2(x * 2, l, r), b = query2(x * 2 + 1, l, r);
        ans.s0 = a.s0 + b.s0;
        ans.s1 = a.s1 + b.s1;
        ans.l1 = a.s0 ? a.l1 : a.s1 + b.l1;
        ans.r1 = b.s0 ? b.r1 : b.s1 + a.r1;
        ans.l0 = a.s1 ? a.l0 : a.s0 + b.l0;
        ans.r0 = b.s1 ? b.r0 : b.s0 + a.r0;
        ans.m1 = max(a.l1, max(a.r1 + b.l1, b.r1));
        ans.m0 = max(a.l0, max(a.r0 + b.l0, b.r0));
        return ans;
    }
}

void check(int x, int l, int r){//调试用的 
    if(l == r){
        cout << t[x].s1 << ' ';
        return;
    }
    push_down(x);
    int mid = l + r >> 1;
    check(x * 2, l, mid);
    check(x * 2 + 1, mid + 1, r);
}

int main(){
    scanf("%d%d", &n, &m);
    for(int i = 0; i <= n - 1; i++){
        scanf("%d", &a[i]);
    }
    build(1, 0, n - 1);
    while(m--){
        int op, l, r;
        scanf("%d%d%d", &op, &l, &r);
        if(op < 3){
            update(1, l, r, op);
        }else if(op == 3){
            int ans = query1(1, l, r);
            printf("%d\n", ans);
        }else{
            tree ans = query2(1, l, r);
            printf("%d\n", ans.m1);
        }
        //check(1, 0, n - 1);
        //cout << endl;
    }
    return 0;
}

可能没人想看 改很久了 来碰碰运气