10pts求调

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n,m,a[N];
struct SegmentTree{
	struct node{
		int l,r,sz;
		int sum,tag,lz;
		int lsum1,rsum1,dat1;
		int lsum0,rsum0,dat0;
	}t[N<<2];
	inline void pushup(node &p,node &l,node &r){
		p.sum=l.sum+r.sum;
		p.lsum0=l.lsum0+(l.lsum0==l.sz?r.lsum0:0);
		p.rsum0=r.rsum0+(r.rsum0==r.sz?l.rsum0:0);
		p.lsum1=l.lsum1+(l.lsum1==l.sz?r.lsum1:0);
		p.rsum1=r.rsum1+(r.rsum1==r.sz?l.rsum1:0);
		p.dat0=max(max(l.dat0,r.dat0),l.rsum0+r.lsum0);
		p.dat1=max(max(l.dat1,r.dat1),l.rsum1+r.lsum1);
	}
	inline void pushdown(int p){
		if (~t[p].tag){
			int l=(p<<1),r=(p<<1|1),v=t[p].tag;
			
			t[l].sum=v*t[l].sz;
			t[l].lsum0=(v?0:t[l].sz);
			t[l].rsum0=(v?0:t[l].sz);
			t[l].dat0=(v?0:t[l].sz);
			t[l].lsum1=(!v?0:t[l].sz);
			t[l].rsum1=(!v?0:t[l].sz);
			t[l].dat1=(!v?0:t[l].sz);
			t[l].tag=v;
			
			t[r].sum=v*t[r].sz;
			t[r].lsum0=(v?0:t[r].sz);
			t[r].rsum0=(v?0:t[r].sz);
			t[r].dat0=(v?0:t[r].sz);
			t[r].lsum1=(!v?0:t[r].sz);
			t[r].rsum1=(!v?0:t[r].sz);
			t[r].dat1=(!v?0:t[r].sz);
			t[r].tag=v;
			
			t[p].tag=-1;
			t[p].lz=0;
		}
		if (t[p].lz){
			int l=(p<<1),r=(p<<1|1);
			
			if(~t[l].tag) t[l].tag^=1;
			else t[l].lz^=1;
			if(~t[r].tag) t[r].tag^=1;
			else t[r].lz^=1;
			
			t[l].sum=t[l].sz-t[l].sum;
			swap(t[l].lsum1,t[l].lsum0);
			swap(t[l].rsum1,t[l].rsum0); 
			swap(t[l].dat1,t[l].dat0);
			
			t[r].sum=t[r].sz-t[r].sum;
			swap(t[r].lsum1,t[r].lsum0);
			swap(t[r].rsum1,t[r].rsum0); 
			swap(t[r].dat1,t[r].dat0);
			
			t[p].lz=0;
		}
	}
	inline void build(int p,int l,int r){
		t[p].l=l;t[p].r=r;t[p].sz=r-l+1;
		t[p].tag=-1;t[p].lz=0;
		if (l==r){
			t[p].sum=a[l];
			t[p].lsum0=t[p].rsum0=t[p].dat0=!a[l];
			t[p].lsum1=t[p].rsum1=t[p].dat1=a[l];
			return ;
		}int mid=(l+r)>>1;
		build(p<<1,l,mid);
		build(p<<1|1,mid+1,r);
		pushup(t[p],t[p<<1],t[p<<1|1]);
	}
	inline int asksum(int p,int l,int r){
		if (l<=t[p].l&&r>=t[p].r)
			return t[p].sum;
		pushdown(p);
		int mid=(t[p].l+t[p].r)>>1,val=0;
		if (l<=mid) val+=asksum(p<<1,l,r);
		if (r>mid) val+=asksum(p<<1|1,l,r);
		return val;
	}
	inline node askdat_init(int p,int l,int r){
		if (l<=t[p].l&&r>=t[p].r) return t[p];
		int mid=(t[p].l+t[p].r)>>1;
		pushdown(p);
		if (r<=mid) return askdat_init(p<<1,l,r);
		if (l>mid) return askdat_init(p<<1|1,l,r);
		node pl=askdat_init(p<<1,l,r);
		node pr=askdat_init(p<<1|1,l,r),ans;
		pushup(ans,pl,pr);
		return ans;
	}
	inline int askdat(int p,int l,int r){
		return askdat_init(p,l,r).dat1;
	}
	inline void update1(int p,int l,int r,int v){
		if (l<=t[p].l&&r>=t[p].r){
			t[p].sum=v*t[p].sz;
			t[p].lsum0=(v?0:t[p].sz);
			t[p].rsum0=(v?0:t[p].sz);
			t[p].dat0=(v?0:t[p].sz);
			t[p].lsum1=(!v?0:t[p].sz);
			t[p].rsum1=(!v?0:t[p].sz);
			t[p].dat1=(!v?0:t[p].sz);
			t[p].tag=v;
			return ;
		}pushdown(p);
		int mid=(t[p].l+t[p].r)>>1;
		if (l<=mid) update1(p<<1,l,r,v);
		if (r>mid) update1(p<<1|1,l,r,v);
		pushup(t[p],t[p<<1],t[p<<1|1]);
	}
	inline void update2(int p,int l,int r){
		if (l<=t[p].l&&r>=t[p].r){
			t[p].sum=t[p].sz-t[p].sum;
			swap(t[p].lsum1,t[p].lsum0);
			swap(t[p].rsum1,t[p].rsum0); 
			swap(t[p].dat1,t[p].dat0);
			t[p].lz^=1;
			return ;
		}pushdown(p);
		int mid=(t[p].l+t[p].r)>>1;
		if (l<=mid) update2(p<<1,l,r);
		if (r>mid) update2(p<<1|1,l,r);
		pushup(t[p],t[p<<1],t[p<<1|1]);
	}
}st;
int main(){
	cin>>n>>m;
	for (int i=1;i<=n;i++) cin>>a[i];
	st.build(1,1,n);
	while (m--){
		int op,l,r,ll,rr;
		cin>>op>>l>>r;++l;++r;
		if (l>r) swap(l,r);
		if (op==0) st.update1(1,l,r,0);
		if (op==1) st.update1(1,l,r,1);
		if (op==2) st.update2(1,l,r);
		if (op==3) cout<<st.asksum(1,l,r)<<'\n';
		if (op==4) cout<<st.askdat(1,l,r)<<'\n';
	}
	return 0;
}