洛谷P4135 作诗（不一样的分块）

题面

🔗

给定一个长度为 $n$ 的整数序列 $A$ ，序列中每个数在 $[1,c]$ 范围内。有 $m$ 次询问，每次询问查询一个区间 $[l,r]$，问有多少个数在该区间中出现了偶数次，强制在线。

$n,m,c\le 10^5$.

题解

这道题的大方向是分块。

第一个做法是时间复杂度标准 $O(n\sqrt{n})$ 的做法。

预处理分块数组

有很多种预处理方法，笔者就介绍一种吧（给后面的时间复杂度更优做法腾出空间）

我们令 $f[i][j]$ 为从块 $i$ 开始到数列第 $j$ 个元素的答案，令 $c[i][j]$ 为从块 $i$ 开始，直到结束，数字 $j$ 出现的次数。

这两者都很好预处理。然后询问的时候，先把 $f[belong[l]+1][r]$ 算进答案，再处理最左边的尾巴剩的那 $O(\sqrt{n})$ 个数。每个数的出现次数可以通过 $c[belong[l]+1]-c[belong[r]]$ 再加上块 $belong[r]$ 内枚举求出（后者得先处理，不然复杂度不对）。

很经典啊，但是我看了看评测记录，大多数人用这种分块跑了 4s +。

不够优啊。于是笔者想出了一种复杂度"更优"的做法。

数据结构分块讨论

设块大小为 $B$ ，

出现次数大于 $B$ 的数字不超过 $\frac{n}{B}$ 个，我们把这些数字出现次数的奇偶性状态全部用一个长度为 $\frac{n}{B}$ 的 bitset 表示，然后直接做前缀异或，再随便（用可持久化线段树）维护任意区间出现数字的种类数。这部分贡献的时间复杂度 $O(n\frac{n}{64B})$ 。

出现次数小于等于 $B$ 的数，就用可持久化线段树暴力维护。维护任意区间的答案，每次把当前位置 $R=i$ 前方与其相等的数都拿出来，令其位置为 $b_1,b_2,...,b_k$，然后该数在 $L\in (b_{k-1},b_k]$ 产生新贡献（这时 $[L,R]$ 内刚好有两个数等于 $a_i$） ，在 $L\in (0,b_1],(b_1,b_2],...,(b_{k-2},b_{k-1}]$ 的贡献分别取反。时间复杂度 $O(n\log n\cdot B)$ 。

设置一个合理的 $B$ ，可以使时间复杂度达到 $O(n\sqrt{n\cdot \frac{\log n}{64}})$，常数相当，理论上更优。

终于跑进了 4s 内（3.87 s）

CODE

数据结构分块讨论的代码：

#include<set>
#include<map>
#include<stack>
#include<cmath>
#include<ctime>
#include<queue>
#include<bitset>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<regex>
using namespace std;
#define MAXN 100005
#define LL long long
#define ULL unsigned long long
#define UI unsigned int
#define DB double
#define ENDL putchar('\n')
#define lowbit(x) (-(x) & (x))
#define FI first
#define SE second
#define eps (1e-4)
#define BI bitset<10001>
#define SQ 10
LL read() {
	LL f=1,x=0;char s = getchar();
	while(s < '0' || s > '9') {if(s=='-')f = -f;s = getchar();}
	while(s >= '0' && s <= '9') {x=x*10+(s-'0');s = getchar();}
	return f*x;
}
void putpos(LL x) {
	if(!x) return ;
	putpos(x/10); putchar('0'+(x%10));
}
void putnum(LL x) {
	if(!x) putchar('0');
	else if(x < 0) putchar('-'),putpos(-x);
	else putpos(x);
}
void AIput(LL x,char c) {putnum(x);putchar(c);}
int n,m,s,o,k;
BI sm[MAXN];
int pr[MAXN];
struct it{
	int ls,rs;
	int nm;
	it(){ls=rs=nm=0;}
}tr[MAXN*64];
int cnt,rt[MAXN];
int addtr(int a,int l,int r,int al,int ar,int y) {
	if(l > r || al > r || ar < l) return a;
	tr[++ cnt] = tr[a]; a = cnt;
	if(al >= l && ar <= r) {tr[a].nm += y;return a;}
	int md = (al + ar) >> 1;
	tr[a].ls = addtr(tr[a].ls,l,r,al,md,y);
	tr[a].rs = addtr(tr[a].rs,l,r,md+1,ar,y);
	return a;
}
int findtr(int a,int x,int al,int ar) {
	if(al > x || ar < x || !a) return 0;
	if(al == ar) return tr[a].nm;
	int md = (al + ar) >> 1;
	return tr[a].nm + findtr(tr[a].ls,x,al,md) + findtr(tr[a].rs,x,md+1,ar);
}
vector<pair<int,int>> tre[MAXN<<2];
int M;
void maketree(int n) {
	M = 1;while(M < n+2)M <<= 1;
	for(int i = 1;i <= M*2-1;i ++) {
		tre[i].clear(); tre[i].push_back(make_pair(0,0));
	}return ;
}
void ins(int s,int y,int tm) {
	int ls = tre[s].back().SE;
	if(tre[s].back().FI == tm) tre[s].pop_back();
	tre[s].push_back(make_pair(tm,y+ls));
}
void addtree(int l,int r,int y,int tm) {
	if(l > r) return ;
	int s = M+l-1,t = M+r+1;
	while(s || t) {
		if((s>>1) != (t>>1)) {
			if(!(s&1)) ins(s^1,y,tm);
			if(t & 1) ins(t^1,y,tm);
		}else break;
		s >>= 1;t >>= 1;
	}return ;
}
int findtree(int x,int tm) {
	int s = M+x,as = 0;
	while(s) as += tre[s][upper_bound(tre[s].begin(),tre[s].end(),make_pair(tm,0x7f7f7f7f))-tre[s].begin()-1].SE,s >>= 1;
	return as;
}
int ct[MAXN],a[MAXN];
int po[MAXN],cn;
vector<int> bu[MAXN];
int main() {
	n = read();m = read();int T = read();
	for(int i = 1;i <= n;i ++) {
		a[i] = read();
		ct[a[i]] ++;
	}
	for(int i = 1;i <= m;i ++) {
		if(ct[i] > SQ) {
			po[i] = ++ cn;
		}
	}
	rt[0] = 0;
	for(int i = 1;i <= n;i ++) {
		rt[i] = rt[i-1];
		if(po[a[i]]) {
			sm[i][po[a[i]]] = 1;
			rt[i] = addtr(rt[i],pr[a[i]] + 1,i,1,n,1);
			pr[a[i]] = i;
		}
		sm[i] ^= sm[i-1];
	}
	maketree(n);
	for(int i = 1;i <= n;i ++) {
		int x = a[i];
		if(!po[x]) {
			for(int j = (int)bu[x].size()-1,ct=1;j >= 0;j --,ct++) {
				int y = bu[x][j],pre = (j == 0 ? 0:bu[x][j-1]);
				if(ct & 1) addtree(pre+1,y,1,i);
				else addtree(pre+1,y,-1,i);
			}
			bu[x].push_back(i);
		}
	}
	int las = 0;
	while(T --) {
		s = read();o = read();
		s = (s + las) % n + 1;
		o = (o + las) % n + 1;
		if(s > o) swap(s,o);
		las = findtree(s,o);
		BI as = sm[o] ^ sm[s-1];
		las += findtr(rt[o],s,1,n) - (int)as.count();
		AIput(las,'\n');
	}
	return 0;
}

在这之后，我又打了一份第一个做法的代码，无优化交上去 2.90 秒 Rank#1

蚌埠住了

#include<set>
#include<map>
#include<stack>
#include<cmath>
#include<ctime>
#include<queue>
#include<bitset>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<regex>
using namespace std;
#define MAXN 100005
#define LL long long
#define ULL unsigned long long
#define UI unsigned int
#define DB double
#define ENDL putchar('\n')
#define lowbit(x) (-(x) & (x))
#define FI first
#define SE second
#define eps (1e-4)
#define SQ 320
LL read() {
	LL f=1,x=0;char s = getchar();
	while(s < '0' || s > '9') {if(s=='-')f = -f;s = getchar();}
	while(s >= '0' && s <= '9') {x=x*10+(s-'0');s = getchar();}
	return f*x;
}
void putpos(LL x) {
	if(!x) return ;
	putpos(x/10); putchar('0'+(x%10));
}
void putnum(LL x) {
	if(!x) putchar('0');
	else if(x < 0) putchar('-'),putpos(-x);
	else putpos(x);
}
void AIput(LL x,char c) {putnum(x);putchar(c);}
int n,m,s,o,k;
int a[MAXN],nx[MAXN],ps[MAXN];
int cn,bl[MAXN];
int f[SQ+2][MAXN],ct[MAXN];
int c[SQ+2][MAXN];
int main() {
	n = read();m = read();int T = read();
	for(int i = 1;i <= n;i ++) {
		a[i] = read();
		int B = i/SQ+1;
		if(!bl[B]) bl[B] = i;
		cn = B;
	}
	for(int i = 1;i <= m;i ++) ps[i] = n+1;
	for(int i = n;i > 0;i --) {
		nx[i] = ps[a[i]];
		ps[a[i]] = i;
	}
	for(int i = 1;i <= cn;i ++) {
		for(int j = bl[i];j <= n;j ++) {
			f[i][j] = f[i][j-1];
			int x = a[j];
			c[i][x] ++;
			if(c[i][x] > 1) {
				if(c[i][x] & 1) f[i][j] --;
				else f[i][j] ++;
			}
		}
	}
	int las = 0;
	while(T --) {
		s = read();o = read();
		s = (s + las) % n + 1;
		o = (o + las) % n + 1;
		if(s > o) swap(s,o);
		int ll = s/SQ+1,rr = o/SQ+1;
		las = 0;
		if(ll == rr) {
			for(int i = s;i <= o;i ++) {
				ct[a[i]] ++;
			}
			for(int i = s;i <= o;i ++) {
				if(ct[a[i]] > 0 && ct[a[i]]%2==0) las ++;
				ct[a[i]] = 0;
			}
		}
		else {
			las = f[ll+1][o];
			for(int i = s;i/SQ+1 == ll;i ++) {
				ct[a[i]] = c[ll+1][a[i]] - c[rr][a[i]];
			}
			for(int i = o;i/SQ+1 == rr;i --) {
				ct[a[i]] ++;
			}
			for(int i = bl[ll+1]-1;i >= s;i --) {
				int x = a[i];
				ct[x] ++;
				if(ct[x] > 1) {
					if(ct[x] & 1) las --;
					else las ++;
				}
			}
			for(int i = s;i < bl[ll+1];i ++) {
				ct[a[i]] = 0;
			}
			for(int i = o;i/SQ+1 == rr;i --) {
				ct[a[i]] = 0;
			}
		}
		AIput(las,'\n');
	}
	return 0;
}

于是我才发现，由于第二个做法处理 $\le B$ 的数时，用朴素的可持久化线段树空间开不下，于是我用了基于vector的可持久化数组，空间只用了 1/3 。缺点就是，查询的复杂度变成了 $O({\log }^{2}n)$ ，成为复杂度瓶颈，于是总复杂度变成 $O(m{\log }^{2}n)$ 。