[UNR#5]诡异操作

题目

传送门 to UOJ

思路

整除操作，可以考虑暴力。问题在于，我们要怎样维护可以快速 $\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{d}$ 的结构，使得整除之后暴力 pushUp 的速度不算太慢？

很容易想到拆位，每一位记录一下，有多少个数在这一位上是 $1$ 。那么做 $\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{d}$ 需要 $\mathcal{O}(\log V)$，整除之后修改结果也是 $\mathcal{O}(\log V)$ 。整除过程中，每个节点势能为 $\mathcal{O}(\log V)$，所以分析出上界为 $\mathcal{O}(n{\log }^{2}V)$ 。而 $\log V$ 达到了惊人的 $128$，根本过不了。

这时候，我们想到一个神奇的 “分块”，那就是 $\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{s}\mathrm{e}\mathrm{t}$ 。同时对 $\omega$ 位进行操作，却是 $\mathcal{O}(1)$ 的时间，这是一个 $\mathrm{b}\mathrm{u}\mathrm{g}$ 般的存在！因为它真的是 让暴力变快，而不是减少冗余信息计算！

于是考虑将那 $\log V$ 个二进制位，用 $\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{s}\mathrm{e}\mathrm{t}$ 实现 “变为零” 的操作。但是 $\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{s}\mathrm{e}\mathrm{t}$ 又只针对 $0,1$ 啊！所以我们对 值（因变量） 进行拆位。有一种比较形象的说法是，将第 $x$ 个 $\text{bit}$ 的出现次数 $c_x$ 用二进制写出来（写在一列上），那么原本我们是按照列存储，现在变为按照行存储，因为行数更少。

用 $r_x$ 状压存储出现次数的 $x\text{-bit}$ 为 $1$ 的比特位。$\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{a}\mathrm{n}\mathrm{d}$ 操作就是对每个 $r_x$ 进行按位与。时间复杂度 $\mathcal{O}(\log L)$，其中 $L$ 为区间长度。而 pushUp 可以用大整数加法的方式实现（相当于并行，毕竟进位也是 $0,1$，也可以用 $\mathrm{b}\mathrm{i}\mathrm{t}\mathrm{s}\mathrm{e}\mathrm{t}$ 存储），也是 $\mathcal{O}(\log L)$ 。

复杂度是什么呢？老规矩，势能。一个被完全覆盖的节点要往下递归，最多 $\mathcal{O}(\log V)$ 次。整棵树的代价和 $T(n)=2T(\frac{n}{2})+\mathcal{O}(\log n)=\mathcal{O}(n)$，所以势能带来的代价是 $\mathcal{O}(n\log V)$，加上一般复杂度 $\mathcal{O}(q{\log }^{2}n)$ 可过。

代码

容易编译超时，建议 Clang 编译。

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cctype>
using namespace std;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
typedef long long llong;
inline int readint(){
	int a = 0, c = getchar(), f = 1;
	for(; !isdigit(c); c=getchar())
		if(c == '-') f = -f;
	for(; isdigit(c); c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}

typedef __uint128_t ulllong;
void readHex(ulllong &v){
	static int8_t haxi[1<<8];
	static bool done = false; if(!done){
		memset(haxi,-1,1<<8); // not good
		done = true; rep(i,0,9) haxi[i^48] = int8_t(i);
		rep(i,'a','f') haxi[i] = int8_t(i-'a'+10);
	}
	v = 0; int c = getchar(); // read by hex
	for(; ~haxi[c]; c=getchar()) v = (v<<4)^haxi[c];
}
void writeHex(const ulllong &v){
	if(v>>4) writeHex(v>>4);
	if((v&15) < 10) putchar(int((v&15)^48));
	else putchar(int((v&15)-10+'a'));
}

const int LOST = 1<<19; ///< length of segment tree
ulllong a[LOST|1]; ///< original array
template < int dep > ///< log(len)+1
struct Node{
	Node<dep-1> lson, rson;
	ulllong v[dep], sum, tag;
	Node():tag(~ulllong(0)){}
	void operator &= (const ulllong &w){
		tag &= w, sum = 0;
		for(int i=0; i!=dep; ++i)
			v[i] &= w, sum += v[i]<<i;
	}
	void pushDown(){
		lson &= tag, rson &= tag;
		tag = compl ulllong(0);
	}
	void pushUp(){
		ulllong &co = v[dep-1] = 0;
		for(int i=0; i!=dep-1; ++i){
			v[i] = lson.v[i] xor co xor rson.v[i];
			co = (lson.v[i]&(co|rson.v[i]))|(co&rson.v[i]);
		}
		sum = lson.sum+rson.sum;
	}
	void build(int l=1,int r=LOST){
		lson.build(l,(l+r)>>1), rson.build((l+r+2)>>1,r);
		pushUp(); // update sum and v
	}
	void div(int ql,int qr,const ulllong &qv,int l=1,int r=LOST){
		if(!sum || qr < l || r < ql) return ; // empty
		pushDown(), lson.div(ql,qr,qv,l,(l+r)>>1);
		rson.div(ql,qr,qv,(l+r+2)>>1,r), pushUp();
	}
	void band(int ql,int qr,const ulllong &qv,int l=1,int r=LOST){
		if(qr < l || r < ql) return ;
		if(ql <= l && r <= qr) return void(*this &= qv);
		pushDown(), lson.band(ql,qr,qv,l,(l+r)>>1);
		rson.band(ql,qr,qv,(l+r+2)>>1,r), pushUp();
	}
	ulllong query(int ql,int qr,int l=1,int r=LOST){
		if(qr < l || r < ql) return ulllong(0);
		if(ql <= l && r <= qr) return sum;
		pushDown(); return lson.query(ql,qr,l,(l+r)>>1)
			+ rson.query(ql,qr,(l+r+2)>>1,r);
	}
};
template < > // specialization
struct Node<1>{
	ulllong sum, *v;
	Node():sum(0),v(&sum){}
	void operator &= (const ulllong &w){
		sum &= w; // the same as v[0]
	}
	void div(int ql,int qr,const ulllong &qv,int l,int r){
		if(ql <= l && r <= qr) sum /= qv;
	}
	void band(int ql,int qr,const ulllong &qv,int l,int r){
		if(ql <= l && r <= qr) sum &= qv;
	}
	void build(int l,int r){ sum = a[l]; }
	ulllong query(int ql,int qr,int l,int r){
		return (ql <= l && r <= qr) ? sum : 0;
	}
};

Node<20> sgt;
int main(){
	int n = readint(), q = readint();
	rep(i,1,n) readHex(a[i]);
	sgt.build();
	for(int op,l,r; q; --q){
		op = readint(), l = readint(), r = readint();
		if(op == 3){
			writeHex(sgt.query(l,r));
			putchar('\n'); continue;
		}
		ulllong v; readHex(v);
		if(op == 1 && v != 1) sgt.div(l,r,v);
		else if(op == 2) sgt.band(l,r,v);
	}
	return 0;
}