P5670 秘籍-反复异或 Solution

Description

给定序列 $a=(a_1,a_2,\cdots ,a_n)$ 和常数 $m$，有 $q$ 个操作分两种：

• $\mathrm{add}(l,r,x)$：对每个 $i\in [l,r]$ 执行 $a_i\leftarrow a_i+x$.
• $\mathrm{query}(l,r)$：求 $(\underset{i=l}{\overset{r}{\mathrm{xor}}}{a}_i)\mathrm{mod}{2}^m$.

Limitations

$1\le n,q\le 10^5$
$1\le m\le 10$
$0\le a_i,x<2^m$
$0.5\text{s},256\text{MB}$

Solution

$m$ 很小，考虑基于值域的做法.
由于异或性质，我们只用维护一个数出现次数奇偶性，这可以压在一个 $1024$ 位的 bitset $f$ 里，第 $i$ 位表示 $i$ 的出现次数奇偶性.
那么合并就是将两个 bitset $\mathrm{xor}$ 起来.
区间加 $x$ 就是将 $f$ 循环左移 $x$ 次，可以写作：

 f = (f >> (1024 - x)) | (f << x);

显然可用线段树维护，记得卡常，用 fastio.

Code

$4.63\text{KB},2.79\text{s},55.88\text{MB}\text{(in total, C++20 with O2)}$
fastio 和 lazy_segment 删了.

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

using i64 = long long;
using ui64 = unsigned long long;
using i128 = __int128;
using ui128 = unsigned __int128;
using f4 = float;
using f8 = double;
using f16 = long double;

template<class T>
bool chmax(T &a, const T &b){
	if(a < b){ a = b; return true; }
	return false;
}

template<class T>
bool chmin(T &a, const T &b){
	if(a > b){ a = b; return true; }
	return false;
}

namespace fastio {}   // Removed

using fastio::read;
using fastio::write;

template<class Info, class Tag>
struct lazy_segment{};   // Removed

constexpr int B = 1024, mask = 1023;

struct Tag {
	int tag;
	inline Tag() : tag(0) {}
	inline Tag(int _tag) : tag(_tag) {}
	inline void apply(const Tag& t) { tag += t.tag; tag &= mask; }
};

struct Info {
	bitset<B> bs;
	inline Info() {}
	inline Info(int x) { bs.reset(); bs[x] = 1; }
	inline void apply(const Tag& t) {
		bs = (bs >> (B - t.tag)) | (bs << t.tag);
	}
};

inline Info operator+(const Info& lhs, const Info& rhs) {
	Info res;
	res.bs = lhs.bs ^ rhs.bs;
	return res;
}

signed main() {
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	
	const int n = read<int>(), m = read<int>(), q = read<int>();
	vector<int> a(n);
	for (int i = 0; i < n; i++) a[i] = read<int>();
	
	lazy_segment<Info, Tag> sgt(a);
	for (int i = 0, op, l, r; i < q; i++) {
		op = read<int>(), l = read<int>(), r = read<int>();
		l--, r--;
		if (op == 1) sgt.apply(l, r, read<int>());
		else {
			auto bs = sgt.query(l, r).bs;
			int ans = 0;
			for (int i = 0; i < B; i++) ans ^= bs[i] * i;
			write(ans & ((1 << m) - 1));
			putchar_unlocked('\n');
		}
	}
	
	return 0;
}