rt，代码:

//# pragma GCC optimize("Ofast,no-stack-protector")
//
//# pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

# include <bits/stdc++.h>

# define I return

# define AK 0

# define IOI ;

using namespace std;

typedef long long ll;

typedef pair <int, int> pii;

struct node {

	int s, l1, r1, max1, l0, r0, max0, len, lazy;

	bool swp;

} tr[400005];

int n, m, a[100005], op, x, y;

void pushup (node& x, const node& l, const node& r) {

	x.s = l.s + r.s;

	x.l1 = l.l1 == l.len ? l.len + r.l1 : l.l1, x.l0 = l.l0 == l.len ? l.len + r.l0 : l.l0;

	x.r1 = r.r1 == r.len ? r.len + l.r1 : r.r1, x.r0 = r.r0 == r.len ? r.len + l.r0 : r.r0;

	x.max1 = max ({l.max1, r.max1, l.r1 + r.l1}), x.max0 = max ({l.max0, r.max0, l.r0 + r.l0});

	return ;

}

void build (int x, int l, int r) {
//	cerr << x << ':' << l << '~' << r << '\n';
	if (l == r) {

		if (a[l])
			tr[x].s = tr[x].l1 = tr[x].r1 = tr[x].max1 = 1;
		else
			tr[x].l0 = tr[x].r0 = tr[x].max0 = 1;

		tr[x].len = 1, tr[x].lazy = -1;
//		cerr << l << '~' << r << ':' << tr[x].len << ',' << tr[x].s << ':' << tr[x].l1 << ',' << tr[x].r1 << ';' << tr[x].l0 << ',' << tr[x].r0 << '&' << tr[x].max1 << ',' << tr[x].max0 << '\n';
		return ;

	}

	const int mid = l + r >> 1, left = x << 1, right = left | 1;

	build (left, l, mid), build (right, mid + 1, r);

	pushup (tr[x], tr[left], tr[right]), tr[x].len = tr[left].len + tr[right].len, tr[x].lazy = -1;
//	cerr << l << '~' << r << ':' << tr[x].len << ',' << tr[x].s << ':' << tr[x].l1 << ',' << tr[x].r1 << ';' << tr[x].l0 << ',' << tr[x].r0 << '&' << tr[x].max1 << ',' << tr[x].max0 << '\n';
	return ;

}

void pushdown (node& x, node& l, node& r) {

	if (! x.lazy) {

		l.l0 = l.r0 = l.max0 = l.len, r.r0 = r.max0 = r.len;

		l.s = l.l1 = l.r1 = l.max1 = r.s = r.l1 = r.r1 = r.max1 = 0;

		l.lazy = r.lazy = 0;

		l.swp = r.swp = x.swp = 0, x.lazy = -1;

	} else if (~ x.lazy) {

		l.s = l.l1 = l.r1 = l.max1 = l.len, r.s = r.l1 = r.r1 = r.max1 = r.len;

		l.l0 = l.r0 = l.max0 = r.l0 = r.r0 = r.max0 = 0;

		l.lazy = r.lazy = 1;

		l.swp = r.swp = x.swp = 0, x.lazy = -1;

	} else if (x.swp) {

		l.s = l.len - l.s;

		swap (l.l0, l.l1), swap (l.r0, l.r1), swap (l.max0, l.max1);

		if (~ l.lazy)
			l.lazy = ! l.lazy;
		else
			l.swp = ! l.swp;

		r.s = r.len - r.s;

		swap (r.l0, r.l1), swap (r.r0, r.r1), swap (r.max0, r.max1);

		if (~ r.lazy)
			r.lazy = ! r.lazy;
		else
			r.swp = ! r.swp;

		x.swp = 0;

	}

	return ;

}

void change (const int x, const int l, const int r, const int L, const int R) {

	if (l == L && r == R) {

		if (op)
			tr[x].s = tr[x].l1 = tr[x].r1 = tr[x].max1 = tr[x].len, tr[x].lazy = 1;
		else
			tr[x].s = 0, tr[x].l0 = tr[x].r0 = tr[x].max0 = tr[x].len, tr[x].lazy = 0;

		return ;

	}

	const int mid = l + r >> 1, left = x << 1, right = left | 1;

	pushdown (tr[x], tr[left], tr[right]);

	if (R <= mid)
		change (left, l, mid, L, R);
	else if (L > mid)
		change (right, mid + 1, r, L, R);
	else
		change (left, l, mid, L, mid), change (right, mid + 1, r, mid + 1, R);

	pushup (tr[x], tr[left], tr[right]);

	return ;

}

void swp (const int x, const int l, const int r, const int L, const int R) {

	if (l == L && r == R) {

		tr[x].s = tr[x].len - tr[x].s;

		swap (tr[x].l0, tr[x].l1), swap (tr[x].r0, tr[x].r1), swap (tr[x].max0, tr[x].max1);

		if (~ tr[x].lazy)
			tr[x].lazy = ! tr[x].lazy;
		else
			tr[x].swp = ! tr[x].swp;

		return ;

	}

	const int mid = l + r >> 1, left = x << 1, right = left | 1;

	pushdown (tr[x], tr[left], tr[right]);

	if (R <= mid)
		swp (left, l, mid, L, R);
	else if (L > mid)
		swp (right, mid + 1, r, L, R);
	else
		swp (left, l, mid, L, mid), swp (right, mid + 1, r, mid + 1, R);

	pushup (tr[x], tr[left], tr[right]);

	return ;

}

int finds (const int x, const int l, const int r, const int L, const int R) {

	if (l == L && r == R)
		return tr[x].s;

	const int mid = l + r >> 1, left = x << 1, right = left | 1;

	pushdown (tr[x], tr[left], tr[right]);

	if (R <= mid)
		return finds (left, l, mid, L, R);

	if (L > mid)
		return finds (right, mid + 1, r, L, R);

	return finds (left, l, mid, L, mid) + finds (right, mid + 1, r, mid + 1, R);

}

int find (const int x, const int l, const int r, const int L, const int R) {

	if (l == L && r == R)
		return tr[x].max1;

	const int mid = l + r >> 1, left = x << 1, right = left | 1;

	pushdown (tr[x], tr[left], tr[right]);

	if (R <= mid)
		return find (left, l, mid, L, R);

	if (L > mid)
		return find (right, mid + 1, r, L, R);

	return max ({find (left, l, mid, L, mid), find (right, mid + 1, r, mid + 1, R), min (tr[left].r1, mid - L + 1) + min (tr[right].l1, R - mid)});

}

int main () {

	ios::sync_with_stdio (0);

	cin.tie (0);

	cout.tie (0);

	cin >> n >> m;

	for (int i = 1; i <= n; ++ i)
		cin >> a[i];

	build (1, 1, n);

	while (m --) {

		cin >> op >> x >> y, ++ x, ++ y;

		if (op < 2)
			change (1, 1, n, x, y);
		else if (op < 3)
			swp (1, 1, n, x, y);
		else if (op < 4)
			cout << finds (1, 1, n, x, y) << '\n';
		else
			cout << find (1, 1, n, x, y) << '\n';

	}

	I AK IOI

}
/*
10 1
0 0 0 1 1 0 1 0 1 1
4 0 9
*/