题解 P5607 [Ynoi2013] 无力回天 NOI2017

简要题意

其实我觉得这个部分可以不要，因为这道题的题面还是很清晰的。

你需要维护一个数据结构，支持区间异或和区间求与 \(v\) 的最大异或和。

思路

对于这种区间问题，最容易想到的就是 分块 线段树。

而对于复杂的异或问题，最容易想到的就是 01 Trie 线性基。

合在一起，就是线段是套线性基。（好像还用了顶针的手法）

做这道题之前建议先做 P4839 P哥的桶 那是这一道题的弱化版。

（现在默认大家已经做过P哥的桶了）

P哥的桶中，是单点修改，而这道题是区间修改，用传统的打tag是不方便维护的，我们可以用差分的思想。

Sol1大佬的文章已经有了正确性证明，我这里就口胡一下结论：

我们可以维护异或差分数组 \(b\)，然后每次询问 \([l,r]\) 就在线段树上询问 \([l+1,r]\)，再插入 \(a_l\) 即可。

然后就是一个差分的过程，随便找一个数据结构维护一下即可。（这里是树状数组）

细节

（由于没特判 \(l=r\) \(45\) 分挂了很久）

注意要特判 \(l=r\)，如果 \(l=r\)，那么就可以分类讨论一下，答案就是 \(\max\{\operatorname{BIT.query}(l) \operatorname{xor} v,v\}\)。

下面代码的注释也有说明（虽然是蹩脚的英文的）

代码

（纪念，这是我A的第二道Ynoi，也是第一篇试图提交题解的Ynoi）

里面有一份线性基模板，如果您觉得我的代码好，可以参考。

不用卡常，好耶！

#include <bits/stdc++.h>
#define int long long
using namespace std;

namespace Basis{
	const int MAX_BIT = 30;
	struct Basis{
		int p[MAX_BIT+5];
		int _how_many_numbers_can_xor;
		void clear(){
			memset(p,0,sizeof(p));
			_how_many_numbers_can_xor=0;
		}
		Basis(){
			clear();
		}
		void insert(int x){
			for(int i=MAX_BIT;i>=0;i--){
				if(!(x&(1ll<<i)))continue;
				if(!p[i]){
					p[i]=x;
					_how_many_numbers_can_xor++;
					break;
				}
				x^=p[i];
			}
		}
		int max_xor(int init=0){
			int ans=init;
			for(int i=MAX_BIT;i>=0;i--){
				if((ans^p[i])>ans){
					ans^=p[i];
				}
			}
			return ans;
		}
		bool can_be_xor(int x){
			for(int i=MAX_BIT;i>=0;i--){
				if(x&(1ll<<i))x^=p[i];
			}
			return x==0;
		}
		int numbers_can_xor(){
			return (1ll<<_how_many_numbers_can_xor);
		}
		void expand(Basis &x){
			for(int i=MAX_BIT;i>=0;i--){
				if(x.p[i]){
					insert(x.p[i]);
				}
			}
		}
	};

	Basis merge(Basis x,Basis y){
		for(int i=MAX_BIT;i>=0;i--){
			if(y.p[i])x.insert(y.p[i]);
		}
		return x;
	}
}

int n,m;
int a[50005];

namespace sgt{
	Basis::Basis t[200005];

	void pushup(int i){
		t[i]=Basis::merge(t[i<<1],t[i<<1|1]);
	}
	void build(int i,int l,int r){
		for(int ii=l;ii<=r;ii++){
			t[i].insert(a[ii]);
		}
		if(l==r){
			return;
		}
		int mid=(l+r)>>1;
		build(i<<1,l,mid);
		build(i<<1|1,mid+1,r);
		pushup(i);
	}
	void update(int x,int v,int i,int l,int r){
		if(l==r){
			t[i].clear();
			a[l]^=v;
			t[i].insert(a[l]);
			return;
		}
		int mid=(l+r)>>1;
		if(x<=mid){
			update(x,v,i<<1,l,mid);
		}
		else{
			update(x,v,i<<1|1,mid+1,r);
		}
		pushup(i);
	}
	Basis::Basis query(int ql,int qr,int i,int l,int r){
		if(ql<=l&&r<=qr){
			return t[i];
		}
		Basis::Basis result;
		int mid=(l+r)>>1;
		if(ql<=mid){
			result=merge(result,query(ql,qr,i<<1,l,mid));
		}
		if(qr>mid){
			result=merge(result,query(ql,qr,i<<1|1,mid+1,r));
		}
		return result;
	}
}

namespace BIT{
	int t[50005];
	void clear(){
		memset(t,0,sizeof(t));
	}
	inline int lowbit(int x){
		return x&(-x);
	}
	void update(int p,int v){
		while(p<=n){
			t[p]^=v;
			p+=lowbit(p);
		}
	}
	int query(int p){
		int ret=0;
		while(p){
			ret^=t[p];
			p-=lowbit(p);
		}
		return ret;
	}
}

void getdiff(){
	for(int i=n;i>1;i--){
		a[i]^=a[i-1];
	}
}

signed main(){
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	BIT::clear();
	getdiff();
	for(int i=1;i<=n;i++){
		BIT::update(i,a[i]);
	}
	sgt::build(1,1,n);
	while(m--){
		int op,l,r,v;
		cin>>op>>l>>r>>v;
		if(op==1){
			BIT::update(l,v);
			sgt::update(l,v,1,1,n);
			if((r+1)<=n){
				BIT::update(r+1,v);
				sgt::update(r+1,v,1,1,n);
			}
		}
		else{
			int lft=BIT::query(l);
			if(l==r){
				// If l equals r
				// Then there are only two possibilities:LFT xor v | v
				cout<<max(v,lft^v)<<'\n';
				continue;
			}
			Basis::Basis result=sgt::query(l+1,r,1,1,n);
			result.insert(lft);
			cout<<(result.max_xor(v))<<'\n';
		}
	}
	return 0;
}