能帮到忙的都关！ 给组有效的hack也关关关 求求力

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
#include<unordered_map>
using namespace std;

#define akemi_homura std::ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define endl '\n'
#define int long long
#define PII pair<int,int>

const double pi = acos(-1);
const int mod = 1e9 + 7;
const int MOD = 998244353;
const int M = 1e6 + 5;
const int N = 1e5 + 5;

struct node
{
    int l, r;
    int change, fan;
    int sum;
    int maxl0, maxr0, maxl1, maxr1, ans0, ans1, vl, vr;
};

node t[N << 2];
int a[N];
int n, m;

//void push_up(int now)
//{
//    t[now].sum = t[now << 1].sum + t[now << 1 | 1].sum;
//    t[now].ans0 = max(t[now << 1].ans0, t[now << 1 | 1].ans0);
//    t[now].ans1 = max(t[now << 1].ans1, t[now << 1 | 1].ans1);
//    t[now].maxl0 = t[now << 1].maxl0;
//    t[now].maxr0 = t[now << 1 | 1].maxr0;
//    t[now].maxl1 = t[now << 1].maxl1;
//    t[now].maxr1 = t[now << 1 | 1].maxr1;
//    t[now].vl = t[now << 1].vl;
//    t[now].vr = t[now << 1 | 1].vr;
//    if (t[now << 1].vr == t[now << 1 | 1].vl)
//    {
//        if (t[now << 1].maxl0 == t[now << 1].r - t[now << 1].l + 1)
//            t[now].maxl0 = max(t[now << 1].maxl0, t[now << 1].ans0 + t[now << 1 | 1].maxl0);
//        if (t[now << 1 | 1].maxr0 == t[now << 1 | 1].r - t[now << 1 | 1].l + 1)
//            t[now].maxr0 = max(t[now << 1 | 1].maxr0, t[now << 1 | 1].ans0 + t[now << 1].maxr0);
//        t[now].ans0 = max(t[now].ans0, t[now << 1].maxr0 + t[now << 1 | 1].maxl0);
//        if (t[now << 1].maxl1 == t[now << 1].r - t[now << 1].l + 1)
//            t[now].maxl1 = max(t[now << 1].maxl1, t[now << 1].ans1 + t[now << 1 | 1].maxl1);
//        if (t[now << 1 | 1].maxr1 == t[now << 1 | 1].r - t[now << 1 | 1].l + 1)
//            t[now].maxr1 = max(t[now << 1 | 1].maxr1, t[now << 1 | 1].ans1 + t[now << 1].maxr1);
//        t[now].ans1 = max(t[now].ans1, t[now << 1].maxr1 + t[now << 1 | 1].maxl1);
//    }
//  
//}

void push_up(int now)
{
    t[now].sum = t[now << 1].sum + t[now << 1 | 1].sum;

    t[now].maxl0 = t[now << 1].maxl0;
    t[now].maxl1 = t[now << 1].maxl1;
    if (t[now << 1].sum == t[now << 1].r - t[now << 1].l + 1)
        t[now].maxl1 += t[now << 1 | 1].maxl1;
    if (t[now << 1].sum == 0)
        t[now].maxl0 += t[now << 1 | 1].maxl0;

    t[now].maxr0 = t[now << 1 | 1].maxr0;
    t[now].maxr1 = t[now << 1 | 1].maxr1;
    if (t[now << 1 | 1].sum == t[now << 1 | 1].r - t[now << 1 | 1].l + 1)
        t[now].maxr1 += t[now << 1].maxr1;
    if (t[now << 1 | 1].sum == 0)
        t[now].maxr0 += t[now << 1].maxr0;

    t[now].ans1 = t[now << 1].maxr1 + t[now << 1 | 1].maxl1;
    t[now].ans1 = max(t[now].ans1, t[now].maxl1);
    t[now].ans1 = max(t[now].ans1, t[now].maxr1);

    t[now].ans0 = t[now << 1].maxr0 + t[now << 1 | 1].maxl0;
    t[now].ans0 = max(t[now].ans0, t[now].maxl0);
    t[now].ans0 = max(t[now].ans0, t[now].maxr0);
}

void build(int l, int r, int now)
{
    t[now].l = l;
    t[now].r = r;
    t[now].change = -1;
    if (l == r)
    {
        t[now].sum = a[l];
        if (a[l] == 1)
        {
            t[now].maxl1 = 1;
            t[now].maxr1 = 1;
            t[now].maxl0 = 0;
            t[now].maxr0 = 0;
            t[now].ans0 = 0;
            t[now].ans1 = 1;
        }
        else
        {
            t[now].maxl0 = 1;
            t[now].maxr0 = 1;
            t[now].maxl1 = 0;
            t[now].maxr1 = 0;
            t[now].ans0 = 1;
            t[now].ans1 = 0;
        }
        t[now].vl = a[l];
        t[now].vr = a[l];
        return;
    }
    int mid = l + r >> 1;
    build(l, mid, now << 1);
    build(mid + 1, r, now << 1 | 1);
    push_up(now);

}

void pushdown(int now)
{
    if (t[now].change != -1)
    {
        t[now].fan = 0;
        t[now << 1].change = t[now].change;
        t[now << 1 | 1].change = t[now].change;
        t[now << 1].fan = t[now << 1 | 1].fan = 0;
        if (t[now].change == 1)
        {
            t[now << 1].maxl1 = t[now << 1].r - t[now << 1].l + 1;
            t[now << 1 | 1].maxl1 = t[now << 1 | 1].r - t[now << 1 | 1].l + 1;
            t[now << 1].maxr1 = t[now << 1].r - t[now << 1].l + 1;
            t[now << 1 | 1].maxr1 = t[now << 1 | 1].r - t[now << 1 | 1].l + 1;
            t[now << 1].maxl0 = 0;
            t[now << 1 | 1].maxl0 = 0;
            t[now << 1].maxr0 = 0;
            t[now << 1 | 1].maxr0 = 0;
            t[now << 1].ans0 = 0;
            t[now << 1].ans1 = t[now << 1].r - t[now << 1].l + 1;
            t[now << 1 | 1].ans0 = 0;
            t[now << 1 | 1].ans1 = t[now << 1 | 1].r - t[now << 1 | 1].l + 1;
            t[now << 1].sum = t[now << 1].r - t[now << 1].l + 1;
            t[now << 1 | 1].sum = t[now << 1 | 1].r - t[now << 1 | 1].l + 1;
        }
        else
        {
            t[now << 1].maxl0 = t[now << 1].r - t[now << 1].l + 1;
            t[now << 1 | 1].maxl0 = t[now << 1 | 1].r - t[now << 1 | 1].l + 1;
            t[now << 1].maxr0 = t[now << 1].r - t[now << 1].l + 1;
            t[now << 1 | 1].maxr0 = t[now << 1 | 1].r - t[now << 1 | 1].l + 1;
            t[now << 1].maxl1 = 0;
            t[now << 1 | 1].maxl1 = 0;
            t[now << 1].maxr1 = 0;
            t[now << 1 | 1].maxr1 = 0;
            t[now << 1].ans1 = 0;
            t[now << 1].ans0 = t[now << 1].r - t[now << 1].l + 1;
            t[now << 1 | 1].ans1 = 0;
            t[now << 1 | 1].ans0 = t[now << 1 | 1].r - t[now << 1 | 1].l + 1;
            t[now << 1].sum = 0;
            t[now << 1 | 1].sum = 0;
        }
        t[now].change = -1;
    }
    if (t[now].fan)
    {
        t[now << 1].sum = (t[now << 1].r - t[now << 1].l + 1) - t[now << 1].sum;
        t[now << 1 | 1].sum = (t[now << 1 | 1].r - t[now << 1 | 1].l + 1) - t[now << 1 | 1].sum;
        if (t[now << 1].change != -1)
            t[now << 1].change ^= 1;
        else t[now << 1].fan ^= 1;
        if (t[now << 1 | 1].change != -1)
            t[now << 1 | 1].change ^= 1;
        else t[now << 1 | 1].fan ^= 1;
        swap(t[now << 1].ans0, t[now << 1].ans1);
        swap(t[now << 1].maxl0, t[now << 1].maxl1);
        swap(t[now << 1].maxr0, t[now << 1].maxr1);
        t[now << 1].vl ^= 1;
        t[now << 1].vr ^= 1;

        swap(t[now << 1 | 1].ans0, t[now << 1 | 1].ans1);
        swap(t[now << 1 | 1].maxl0, t[now << 1 | 1].maxl1);
        swap(t[now << 1 | 1].maxr0, t[now << 1 | 1].maxr1);
        t[now << 1 | 1].vl ^= 1;
        t[now << 1 | 1].vr ^= 1;


    }
    t[now].fan = 0;

}

void modify(int l, int r, int now, int op, int x)
{
    if (t[now].l >= l && t[now].r <= r)
    {
        if (op == 0)
        {
            t[now].change = x;
            t[now].fan = 0;
            t[now].vl = x;
            t[now].vr = x;
            if (x == 1)
            {
                t[now].sum = t[now].r - t[now].l + 1;
                t[now].maxl1 = t[now].r - t[now].l + 1;
                t[now].maxr1 = t[now].r - t[now].l + 1;
                t[now].maxl0 = 0;
                t[now].maxr0 = 0;
                t[now].ans1 = t[now].r - t[now].l + 1;
                t[now].ans0 = 0;
            }
            else
            {
                t[now].sum = 0;
                t[now].maxl1 = 0;
                t[now].maxr1 = 0;
                t[now].maxl0 = t[now].r - t[now].l + 1;
                t[now].maxr0 = t[now].r - t[now].l + 1;
                t[now].ans0 = t[now].r - t[now].l + 1;
                t[now].ans1 = 0;
            }
            return;
        }
        else if (op == 1)
        {
            t[now].sum = t[now].r - t[now].l + 1 - t[now].sum;
            if (t[now].change != -1)t[now].change ^= 1;
            else t[now].fan ^= 1;
            t[now].vl ^= 1;
            t[now].vr ^= 1;
            swap(t[now].maxr0, t[now].maxr1);
            swap(t[now].maxl0, t[now].maxl1);
            swap(t[now].ans0, t[now].ans1);
            return;
        }
    }
    pushdown(now);
    int mid = t[now].l + t[now].r >> 1;
    if (l <= mid)modify(l, r, now << 1, op, x);
    if (r >= mid + 1)modify(l, r, now << 1 | 1, op, x);
    push_up(now);
}

node query(int l, int r, int now)
{
    if (t[now].l >= l && t[now].r <= r)
    {
        return t[now];
    }
    pushdown(now);
    int mid = t[now].l + t[now].r >> 1;
    if (mid < l)return query(l, r, now << 1 | 1);
    else if (r < mid + 1)return query(l, r, now << 1);
    else
    {
        node tt, lef = query(l, r, now << 1), rig = query(l, r, now << 1 | 1);
        tt.sum = lef.sum + rig.sum;
        tt.maxl0 = lef.maxl0;
        tt.maxl1 = lef.maxl1;
        tt.maxr0 = rig.maxr0;
        tt.maxr1 = rig.maxr1;
        tt.vl = lef.vl;
        tt.vr = rig.vr;
        if (lef.sum == lef.r - lef.l + 1)
        {
            tt.maxl1 += rig.maxl1;
        }
        if (lef.sum == 0)
        {
            tt.maxl0 += rig.maxl0;
        }
        if (rig.sum == rig.r - rig.l + 1)
        {
            tt.maxr1 += lef.maxr1;
        }
        if (rig.sum == 0)
        {
            tt.maxr0 += lef.maxr0;
        }
        tt.ans1 = max(lef.ans1, rig.ans1);
        tt.ans0 = max(lef.ans0, rig.ans0);
        tt.ans1 = max(tt.ans1, lef.maxr1 + rig.maxl1);
        tt.ans0 = max(tt.ans0, lef.maxr0 + rig.maxl0);

        return tt;
    }

}

int query_sum(int l, int r, int now)
{
    if (t[now].l >= l && t[now].r <= r)
    {
        return t[now].sum;
    }
    pushdown(now);
    int mid = t[now].l + t[now].r >> 1;
    int ans = 0;
    if (l <= mid)ans += query_sum(l, r, now << 1);
    if (r >= mid + 1)ans += query_sum(l, r, now << 1 | 1);
    return ans;
}

void _solve()
{
    cin >> n >> m;
    for (int i = 1; i <= n; i++)cin >> a[i];
    build(1, n, 1);

    while (m--)
    {
        int op; cin >> op;
        int l, r; cin >> l >> r;
        l++; r++;
        if (op == 0)
        {
            modify(l, r, 1, 0, 0);
        }
        else if (op == 1)
        {
            modify(l, r, 1, 0, 1);
        }
        else if (op == 2)
        {
            modify(l, r, 1, 1, -1);
        }
        else if (op == 3)
        {
            cout << query_sum(l, r, 1) << endl;
        }
        else
        {
            cout << query(l, r, 1).ans1 << endl;
        }
    }

}

signed main()
{
    akemi_homura;
    int Case = 1;
    //cin >> Case;
    while (Case--)
    {
        _solve();
    }
    return 0;
}