NOIP训练 与或（线段树）

与或

描述
[外链图片转存失败(img-FSus3rPz-1564220504055)(http://sdoj.cdsdsy.net/images/20180614230737_28117)]
样例输入
5 8
1 3 2 5 4
3 1 3
2 1 1 5
3 1 3
1 1 4 6
2 3 4 1
3 2 3
2 2 3 4
3 1 5
样例输出
3
5
3
7
提示
对于30%数据，N,Q<=2000
另有30%数据，第三类操作L==R
对于100%数据，N,Q<=200000，Ai∈[ 0 , 2^20 )

线段树基础操作，本蒟蒻由大佬科普过两种做法，但总体思路都是一致的，首先我们需要明确|操作和&操作分别的作用是什么，

|操作，即按位或操作，对于两个进行按位或操作的二进制数的同一位，只要其中一个为$1$，那么答案的这一位就为$1$。

&操作，即按位与操作，对于两个进行按位与操作的二进制数的同一位，只要其中一个为$0$，那么答案的这一位就为$0$。

我们总结一下两种操作的作用吧，如果使用按位与来进行修改，那么如果$x$的第$i$位是$0$，那么答案的第$i$位也被强制成了$0$，同理，如果使用按位或来进行修改，那么如果$x$的第$i$位是$1$，那么答案的第$i$位也被强制成了$1$，也就是说，每次操作之后，都有一段区间中的数的某些二进制位被修改成了相同的，而整个序列中相同的二进制位数随着修改次数的增多显然是单调不降的，这样的话，由于每个数最多有$20$位，所以即使我们使用带有暴力思想的线段树也是可以$A$掉这题的。具体怎么实现呢？由于使整个区间二进制位相同的修改次数有了保障，我们不妨直接在修改当前线段树节点的判断条件上做做文章，我们知道原本修改当前线段树节点的判断条件是$(ql\le T[p].l$ $and$ $T[p].r\le qr),$我们如果再增加一个限制条件$T[p].minn==T[p].maxn$，经过验证同样可以过掉随机数据。

---

先来一波假算法卡随机数据的（某学长的）代码：

#include
using namespace std;
const int N=2e5+5,MAX=(1<<20)-1;
int read(){
	int res=0,f=1; char c=getchar();
	for(;!isdigit(c);c=getchar()) if(c=='-') f=-1;
	for(;isdigit(c);c=getchar()) res=(res<<1)+(res<<3)+(c^'0');
	return res*f;
}
int n,a[N],Q;
struct node{
	int ls,rs;
	int max,min,S;
	int tag;
	node(){
		ls=rs=max=S=0;
		tag=-1;
	}
}tr[N<<1];
int rt=0,node=0;
#define gm int mid=s+t>>1;
int &l(int x){return tr[x].ls;}
int &r(int x){return tr[x].rs;}
void set_or(int x,int s){
	tr[x].max|=s;tr[x].min|=s;
	tr[x].tag=tr[x].max;
}
void set_and(int x,int s){
	tr[x].max&=s;tr[x].min&=s;
	tr[x].tag=tr[x].max;
}
void down(int x){
	if(tr[x].tag!=-1){
		tr[l(x)].max=tr[r(x)].max=
		tr[l(x)].min=tr[r(x)].min=
		tr[l(x)].tag=tr[r(x)].tag=tr[x].tag;
		tr[x].tag=-1;
	}
}
void up(int x){
	tr[x].max=max(tr[l(x)].max,tr[r(x)].max);
	tr[x].min=min(tr[l(x)].min,tr[r(x)].min);
}
void build(int &x,int s=1,int t=n){
	x=++node;
	if(s==t){tr[x].max=tr[x].min=a[s];return;}gm;
	build(l(x),s,mid);build(r(x),mid+1,t);
	up(x);
}
void Or(int x,int v,int qs,int qt,int s,int t){
	if(qs<=s&&t<=qt&&tr[x].max==tr[x].min){set_or(x,v);return;}
	gm;down(x);
	if(qs<=mid) Or(l(x),v,qs,qt,s,mid);
	if(qt >mid) Or(r(x),v,qs,qt,mid+1,t);
	up(x);
}
void And(int x,int v,int qs,int qt,int s,int t){
	if(qs<=s&&t<=qt&&tr[x].max==tr[x].min){set_and(x,v);return;}
	gm;down(x);
	if(qs<=mid) And(l(x),v,qs,qt,s,mid);
	if(qt >mid) And(r(x),v,qs,qt,mid+1,t);
	up(x);
}
int que(int x,int qs,int qt,int s,int t){
	if(qs<=s&&t<=qt) return tr[x].max;
	gm;down(x);int res=0;
	if(qs<=mid) res=max(res,que(l(x),qs,qt,s,mid));
	if(qt >mid) res=max(res,que(r(x),qs,qt,mid+1,t));
	return res;
}
int main(){
	n=read();Q=read();
	for(int i=1;i<=n;++i) a[i]=read();
	build(rt,1,n);
	for(int i=1,opt,l,r,x;i<=Q;++i){
		opt=read();l=read();r=read();
		if(opt==1){
			x=read();
			And(rt,x,l,r,1,n);
		}else if(opt==2){
			x=read();
			Or(rt,x,l,r,1,n);
		}else{
			cout << que(rt,l,r,1,n) << '\n';
		}
	}
	return 0;
}

---

然后我们继续思考这道题的正解吧，由于这道题的按位与和按位或操作只会使整个区间的某几位发生强制的变化，所以如果整个修改区间的那几位都是相同的话，这次修改并不影响修改区间的大小顺序，因为每个数相当于都强制变化了同样的值，因此在维护区间最大值的同时，我们同时维护一个叫做$T[p].same$的的二进制数来表示当前区间从第一个二进制位到最后的二进制位的异同性。显然我们可以假设整个区间的第$i$位都相同时$same$的第$i$位为$1$,否则为$0$，这时新问题出现了，如何区间合并$same$的值呢？，我们应该这样思考，如果左右儿子的$same$在第$i$位上有至少一个为$0$，那么说明整个区间一定有不同的第$i$位，然后$T[p].same$显然就为$0$，如果左右儿子的$same$值都为$1$的话，说明左右子区间的数的第$i$位都分别相同，我们再用两个子区间的$maxn$值筛选出整个区间都有可能相同的二进制位，最后再与左右区间的$same$比较一下即可合并了，也就是说$T[p].same=(T[lc].same$ $and$ $T[rc].same)$ $and$ $((T[lc].maxn$ $xor$ $ T[rc].maxn))$,在我们能够维护出$sameKaTeX parse error: Expected 'EOF', got '&' at position 10: 的值过后，对于|（&̲）操作我们只需在判断是否修改当…check$函数的判断就行了，具体方式可以参考本蒟蒻的代码。

然后说说实现该算法的两种思想：

---

第一种：写两个$update$函数打区间标记分别对操作$1,2$进行修改，本蒟蒻调了很久。相比第二种来说思维难度较低，代码有对称性，但容易滑稽。

代码如下：

#include
#define N 200005
#define lc (p<<1)
#define rc (p<<1|1)
#define mid (T[p].l+T[p].r>>1)
#define inf ((1<<20)-1)
using namespace std;
struct Node{
	int l,r,sm,mx,lz1,lz2;
}T[N<<2];
int a[N],n,q;
inline void pushup(int p){
	T[p].mx=max(T[lc].mx,T[rc].mx);
	T[p].sm=(T[lc].sm&T[rc].sm)&(~(T[lc].mx^T[rc].mx));
}
inline void pushnow(int p,int sm,int mx){
	T[p].sm|=sm;
	T[p].mx=(T[p].mx&(~sm))|(mx&sm);
}
inline void pushdown(int p){
	if(T[p].l==T[p].r)return;
	pushnow(lc,T[p].sm,T[p].mx);
	pushnow(rc,T[p].sm,T[p].mx);
}
inline void build(int p,int l,int r){
	T[p].l=l,T[p].r=r,T[p].lz1=T[p].lz2=0;
	if(l==r){T[p].mx=a[l],T[p].sm=inf;return;}
	build(lc,l,mid);
	build(rc,mid+1,r);
	pushup(p);
}
inline bool check1(int p,int v){return ((inf^v)&T[p].sm)==(inf^v);}
inline bool check2(int p,int v){return (T[p].sm&v)==v;}
inline void update1(int p,int ql,int qr,int v){
	pushdown(p);
	if(ql>T[p].r||qr<T[p].l)return;
	if(ql<=T[p].l&&T[p].r<=qr){
		if(T[p].l==T[p].r||check1(p,v)){
			T[p].mx&=v; 
			return;
		}
	}
	if(qr<=mid)update1(lc,ql,qr,v);
	else if(ql>mid)update1(rc,ql,qr,v);
	else update1(lc,ql,mid,v),update1(rc,mid+1,qr,v);
	pushup(p);
}
inline void update2(int p,int ql,int qr,int v){
	pushdown(p);
	if(ql>T[p].r||qr<T[p].l)return;
	if(ql<=T[p].l&&T[p].r<=qr){
		if(T[p].l==T[p].r||check2(p,v)){
			T[p].mx|=v; 
			return;
		}
	}
	if(qr<=mid)update2(lc,ql,qr,v);
	else if(ql>mid)update2(rc,ql,qr,v);
	else update2(lc,ql,mid,v),update2(rc,mid+1,qr,v);
	pushup(p);
}
inline int query(int p,int ql,int qr){
	pushdown(p);
	if(ql>T[p].r||qr<T[p].l)return 0;
	if(ql<=T[p].l&&T[p].r<=qr)return T[p].mx;
	if(qr<=mid)return query(lc,ql,qr);
	if(ql>mid)return query(rc,ql,qr);
	return max(query(lc,ql,mid),query(rc,mid+1,qr));
}
int main(){
	scanf("%d%d",&n,&q);
	for(int i=1;i<=n;++i)scanf("%d",&a[i]);
	build(1,1,n);
	while(q--){
		int op,l,r;
		scanf("%d%d%d",&op,&l,&r);
		if(op==3){
			printf("%d\n",query(1,l,r));
			continue;
		}
		int v;
		scanf("%d",&v);
		if(op==1)update1(1,l,r,v);
		else update2(1,l,r,v);
	}
	return 0;
}

---

第二种：我们利用位运算将按位与的修改转化成为按位或的修改，实现难度较低，但思维要求比较高，请各位大佬务必照着代码中的转化方式自己手推一遍，加深理解。

代码如下：

#include
#define inf (1<<20)-1
#define lc (p<<1)
#define rc (p<<1|1)
#define mid (T[p].l+T[p].r>>1)
#define N 200005
using namespace std;
int n,q,a[N];
struct Node{int l,r,sm,mx;}T[N<<2];
inline void pushnow(int p,int sm,int mx){
	T[p].sm|=sm;
	T[p].mx=(T[p].mx&(~sm))|(mx&sm);
}
inline void pushdown(int p){
	pushnow(lc,T[p].sm,T[p].mx);
	pushnow(rc,T[p].sm,T[p].mx);
}
inline void pushup(int p){
	T[p].sm=(~(T[lc].mx^T[rc].mx))&(T[lc].sm&T[rc].sm);
	T[p].mx=max(T[lc].mx,T[rc].mx);
}
inline void build(int p,int l,int r){
	T[p].l=l,T[p].r=r;
	if(l==r){T[p].sm=inf,T[p].mx=a[l];return;}
	build(lc,l,mid);
	build(rc,mid+1,r);
	pushup(p);
}
inline int query(int p,int ql,int qr){
	if(qr<T[p].l||T[p].r<ql)return 0;
	if(ql<=T[p].l&&T[p].r<=qr)return T[p].mx;
	pushdown(p);
	return max(query(lc,ql,qr),query(rc,ql,qr));
}
inline void update(int p,int ql,int qr,int sm,int v){
	if(qr<T[p].l||T[p].r<ql)return;
	if(ql<=T[p].l&&T[p].r<=qr){
		if(T[p].l==T[p].r||((sm&T[p].sm)==sm)){
			T[p].mx=(T[p].mx&(~sm))|(v&sm);
			return;
		}
	}
	pushdown(p);
	update(lc,ql,qr,sm,v);
	update(rc,ql,qr,sm,v);
	pushup(p);
}

int main(){
	scanf("%d%d",&n,&q);
	for(int i=1;i<=n;++i)scanf("%d",&a[i]);
	build(1,1,n);
	while(q--){
		int op,l,r;
		scanf("%d%d%d",&op,&l,&r);
		if(op==1){
			int v;
			scanf("%d",&v);
			update(1,l,r,inf^v,0);
		}
		if(op==2){
			int v;
			scanf("%d",&v);
			update(1,l,r,v,v);
		}
		if(op==3)printf("%d\n",query(1,l,r));
	}
	return 0;
}

这道题加强了本蒟蒻对线段树（二进制）的理解，毕竟调了一个下午加一个晚上。