BZOJ 1858: [Scoi2010]序列操作 线段树

1858: [Scoi2010]序列操作

Time Limit: 10 Sec  Memory Limit: 64 MB
Submit: 2956  Solved: 1432
[Submit][Status][Discuss]

Description

lxhgww最近收到了一个01序列，序列里面包含了n个数，这些数要么是0，要么是1，现在对于这个序列有五种变换操作和询问操作： 0 a b 把[a, b]区间内的所有数全变成0 1 a b 把[a, b]区间内的所有数全变成1 2 a b 把[a,b]区间内的所有数全部取反，也就是说把所有的0变成1，把所有的1变成0 3 a b 询问[a, b]区间内总共有多少个1 4 a b 询问[a, b]区间内最多有多少个连续的1 对于每一种询问操作，lxhgww都需要给出回答，聪明的程序员们，你们能帮助他吗？

Input

输入数据第一行包括2个数，n和m，分别表示序列的长度和操作数目 第二行包括n个数，表示序列的初始状态 接下来m行，每行3个数，op, a, b，（0 < = op < = 4，0 < = a < = b）

Output

对于每一个询问操作，输出一行，包括1个数，表示其对应的答案

Sample Input

10 10
0 0 0 1 1 0 1 0 1 1
1 0 2
3 0 5
2 2 2
4 0 4
0 3 6
2 3 7
4 2 8
1 0 5
0 5 6
3 3 9

Sample Output

5
2
6
5

HINT

对于30%的数据，1<=n, m<=1000 对于100%的数据，1< = n, m < = 100000

这大抵是功能最全的线段树了。。。

覆盖的优先级要更高，所以好好处理一下

最开始pushdown在下传lazy的时候搞的，怎么调也调不对

看了看hzwer的代码 茅厕顿开

可以在访问每个区间前就pushdown 这样就不用那么费劲了

还是思想江化啊

#include<cmath>
#include<ctime>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<iomanip>
#include<vector>
#include<string>
#include<bitset>
#include<queue>
#include<map>
#include<set>
using namespace std;

inline int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch<='9'&&ch>='0'){x=(x<<1)+(x<<3)+ch-'0';ch=getchar();}
	return x*f;
}
void print(int x)
{if(x<0)putchar('-'),x=-x;if(x>=10)print(x/10);putchar(x%10+'0');}

const int N=100100;

struct seg_tree{int sum,suml,sumr,summ,s,sl,sr,sm,mark1,mark2;}tr[N<<2];

inline void pushup(int k,int l,int r)
{
	int mid=(l+r)>>1;
	tr[k].sum=tr[k<<1].sum+tr[k<<1|1].sum;
	tr[k].summ=max(tr[k<<1|1].summ,tr[k<<1].summ);
	tr[k].summ=max(tr[k].summ,tr[k<<1].sumr+tr[k<<1|1].suml);
	tr[k].suml=tr[k<<1].suml;tr[k].sumr=tr[k<<1|1].sumr;
	if(mid-l+1==tr[k<<1].sum)tr[k].suml=tr[k<<1].sum+tr[k<<1|1].suml;
	if(r-mid==tr[k<<1|1].sum)tr[k].sumr=tr[k<<1|1].sum+tr[k<<1].sumr;
	
	tr[k].s=tr[k<<1].s+tr[k<<1|1].s;
	tr[k].sm=max(tr[k<<1|1].sm,tr[k<<1].sm);
	tr[k].sm=max(tr[k].sm,tr[k<<1].sr+tr[k<<1|1].sl);
	tr[k].sl=tr[k<<1].sl;tr[k].sr=tr[k<<1|1].sr;
	if(mid-l+1==tr[k<<1].s)tr[k].sl=tr[k<<1].s+tr[k<<1|1].sl;
	if(r-mid==tr[k<<1|1].s)tr[k].sr=tr[k<<1|1].s+tr[k<<1].sr;
}

inline void pushdown(int k,int l,int r)
{
	if(l==r)return ;
	if(tr[k].mark1)
	{
		int mid=(l+r)>>1;
		tr[k<<1].mark1=tr[k<<1|1].mark1=tr[k].mark1;
		if(tr[k].mark1==1)
		{
			tr[k<<1].sum=tr[k<<1].suml=tr[k<<1].sumr=tr[k<<1].summ=0;
			tr[k<<1].s=tr[k<<1].sl=tr[k<<1].sr=tr[k<<1].sm=mid-l+1;
			tr[k<<1|1].sum=tr[k<<1|1].suml=tr[k<<1|1].sumr=tr[k<<1|1].summ=0;
			tr[k<<1|1].s=tr[k<<1|1].sl=tr[k<<1|1].sr=tr[k<<1|1].sm=r-mid;
		}
		else 
		{
			tr[k<<1].sum=tr[k<<1].suml=tr[k<<1].sumr=tr[k<<1].summ=mid-l+1;
			tr[k<<1].s=tr[k<<1].sl=tr[k<<1].sr=tr[k<<1].sm=0;
			tr[k<<1|1].sum=tr[k<<1|1].suml=tr[k<<1|1].sumr=tr[k<<1|1].summ=r-mid;
			tr[k<<1|1].s=tr[k<<1|1].sl=tr[k<<1|1].sr=tr[k<<1|1].sm=0;
		}
		tr[k<<1].mark2=tr[k<<1|1].mark2=0;
		tr[k].mark1=0;
	}
	if(tr[k].mark2)
	{
		tr[k<<1].mark2^=1;tr[k<<1|1].mark2^=1;
		swap(tr[k<<1].sum,tr[k<<1].s);
		swap(tr[k<<1].suml,tr[k<<1].sl);
		swap(tr[k<<1].sumr,tr[k<<1].sr);
		swap(tr[k<<1].summ,tr[k<<1].sm);
		swap(tr[k<<1|1].sum,tr[k<<1|1].s);
		swap(tr[k<<1|1].suml,tr[k<<1|1].sl);
		swap(tr[k<<1|1].sumr,tr[k<<1|1].sr);
		swap(tr[k<<1|1].summ,tr[k<<1|1].sm);
		tr[k].mark2=0;
	}
}

void build(int k,int l,int r)
{
	if(l==r)
	{
		tr[k].sum=tr[k].summ=tr[k].suml=tr[k].sumr=read();
		tr[k].s=tr[k].sm=tr[k].sl=tr[k].sr=tr[k].sum^1;
		return ;
	}
	int mid=(l+r)>>1;
	build(k<<1,l,mid);build(k<<1|1,mid+1,r);
	pushup(k,l,r);
}

void modify(int k,int l,int r,int x,int y,int val)
{
	pushdown(k,l,r);
	if(l>=x&&r<=y)
	{
		int len=r-l+1,tmp;
		val?tmp=len:tmp=0;
		tr[k].sum=tr[k].summ=tr[k].suml=tr[k].sumr=tmp;
		tr[k].s=tr[k].sm=tr[k].sl=tr[k].sr=len-tmp;
		tr[k].mark1=val+1;tr[k].mark2=0;
		return ;
	}
	int mid=(l+r)>>1;
	if(x<=mid)modify(k<<1,l,mid,x,y,val);
	if(y>mid)modify(k<<1|1,mid+1,r,x,y,val);
	pushup(k,l,r);
}

void rever(int k,int l,int r,int x,int y)
{
	pushdown(k,l,r);
	if(l>=x&&r<=y)
	{
		tr[k].mark2=1;
		swap(tr[k].sum,tr[k].s);
		swap(tr[k].suml,tr[k].sl);
		swap(tr[k].sumr,tr[k].sr);
		swap(tr[k].summ,tr[k].sm);
		return ;
	}
	int mid=(l+r)>>1;
	if(x<=mid)rever(k<<1,l,mid,x,y);
	if(y>mid)rever(k<<1|1,mid+1,r,x,y);
	pushup(k,l,r);
}

int query_sum(int k,int l,int r,int x,int y)
{
	pushdown(k,l,r);
	if(l>=x&&r<=y)return tr[k].sum;
	int mid=(l+r)>>1;
	if(x>mid)return query_sum(k<<1|1,mid+1,r,x,y);
	if(y<=mid)return query_sum(k<<1,l,mid,x,y);
	return query_sum(k<<1|1,mid+1,r,x,y)+query_sum(k<<1,l,mid,x,y);
}

int query_mx(int k,int l,int r,int x,int y)
{
	pushdown(k,l,r);
	if(l>=x&&r<=y)return tr[k].summ;
	int mid=(l+r)>>1;
	if(x>mid)return query_mx(k<<1|1,mid+1,r,x,y);
	if(y<=mid)return query_mx(k<<1,l,mid,x,y);
	return max(max(query_mx(k<<1|1,mid+1,r,x,y),query_mx(k<<1,l,mid,x,y)),(min(tr[k<<1].sumr,mid-x+1)+min(tr[k<<1|1].suml,y-mid)));
}

int main()
{
	int n=read(),Q=read();
	build(1,1,n);
	register int opt,x,y;
	while(Q--)
	{
		opt=read();x=read()+1;y=read()+1;
		switch(opt)
		{
			case 0:modify(1,1,n,x,y,opt);break;
			case 1:modify(1,1,n,x,y,opt);break;
			case 2:rever(1,1,n,x,y);break;
			case 3:print(query_sum(1,1,n,x,y));puts("");break;
			case 4:print(query_mx(1,1,n,x,y));puts("");break;
		}
	}
	return 0;
}
/*
10 10
0 0 0 1 1 0 1 0 1 1
1 0 2
3 0 5
2 2 2
4 0 4
0 3 6
2 3 7
4 2 8
1 0 5
0 5 6
3 3 9

5
2
6
5
*/