分散层叠算法学习笔记

这里不是洛谷题解，所以扯点题外话

为何我会来学这个东西呢……因为有个大毒瘤 dq 要做分块，听说要用这个算法，我就找了论文，然后一起自闭……

（这种理性愉悦的东西也不怎么实用吧

勉强看完后，发现 command_block 在四月时就弄了个模板题……除了膜还能干啥呢（

然而感觉肝疼，不是很能深入实现，所以现在先写这个半吊子博客弄点绪论。

（还因为目前洛谷那里唯一的题解不是分散层叠

---

本文主要参考 IOI 2020 中国国家候选队论文《浅谈利用分散层叠算法对经典分块问题的优化》。

本文仅描述了该算法的基本思想及实现，更深入的理论及应用请在论文中查阅。（或者哪天我有闲心了来写

本文提供的代码并没有经过精细实现，同时依赖于模板题的一些特殊限制，所以不推荐作为模板使用，也不保证在一般情况下仍然有正确性。

---

分散层叠算法可以解决下述问题：

• 给定 \(k\) 个有序序列，长度的和为 \(n\)。\(q\) 次询问，每次给定数 \(x\)，求出其在每个序列的后继。下文中认为，这个后继是非严格的。

对于 \(k=1\) 是一个经典的二分算法，可以做到 \(O(n)-O(\log n)\)。

这个算法做 \(k\) 次即有 \(O(n)-O(k\log\frac{n}{k})\) 的复杂度。

另一种常见算法，是将这 \(k\) 个序列归并成一个长为 \(n\) 的序列，同时对于每个元素记录其后面第一个来自第 \(i\) 个序列的数是哪个。那么每次查询都可以在大序列中二分，通过在大序列的后继记录的信息得到在每个序列的后继。

这个算法的复杂度为 \(O(nk)-O(k+\log n)\)，同时空间复杂度也是 \(O(nk)\)。

分散层叠算法可以 \(O(n)-O(k+\log n)\) 解决这个问题，且空间复杂度是 \(O(n)\)。

---

我们将一开始给出的第 \(i\) 个序列叫做 \(L_i\)。然后预处理另外 \(k\) 个有序序列 \(M_i\)。

\(M_k=L_k\)，而对于 \(i<k\)，\(M_i\) 由 \(L_i\) 和 \(M_{i+1}'\) 归并得到。其中 \(M_{i+1}'\) 只包含了 \(M_{i+1}\) 下标为偶数的元素。

比如，\(L_2=[3,8,11,14,18],M_3=[9,12,13,15,17]\)，那么 \(M_2=[3,8,11,12,14,15,18]\)。其中的 \(12\) 和 \(15\) 来自 \(M_3\)。

同时，对于 \(M_i\) 中的每一个元素，维护在 \(L_i\) 和 \(M_{i+1}\) 的后继的下标（如果没有，也记录下来）。这个可以在归并的时候维护。

预处理的时间复杂度，注意到 \(L_i\) 会在归并 \(M_i\) 时贡献 \(1\)，归并 \(M_{i-1}\) 时贡献 \(\frac{1}{2}\)，等等。所以每个序列的总贡献系数不超过 \(2\)，也即时空复杂度均为 \(O(n)\)。

---

对于一次询问，先二分出 \(x\) 在 \(M_1\) 中的后继，设为 \(y\)（如果没有，还要特判）。

注意到 \(L_1\) 的元素在 \(M_1\) 中均有出现，所以 \(y\) 在 \(L_1\) 的后继就是 \(x\) 在 \(L_1\) 的后继。

我们也知道 \(y\) 在 \(M_2\) 的后继。注意到 \(y\) 在 \(M_2\) 的后继和 \(x\) 在 \(M_2\) 的后继下标相差是 \(O(1)\) 的。

这是因为 \(x\) 在 \(M_2\) 的后继，和这个后继的后一个元素，恰好一个在 \(M_1\) 中出现，所以 \(y\) 肯定不会大于 \(x\) 在 \(M_2\) 的后继的后一个，\(y\) 在 \(M_2\) 的后继也不会。

所以如果我们知道 \(x\) 在 \(M_i\) 的后继，就可以 \(O(1)\) 求出 \(x\) 在 \(M_{i+1}\) 和 \(L_i\) 的后继。

此时我们就做到了 \(O(n)-O(k+\log n)\) 的复杂度。

---

下面给出洛谷 P6466 的代码实现，时间复杂度为 \(O(nk+qk+q\log n)\)。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
const int maxn=22222,maxk=111,mod=998244353;
#define MP make_pair
#define PB push_back
#define lson o<<1,l,mid
#define rson o<<1|1,mid+1,r
#define FOR(i,a,b) for(int i=(a);i<=(b);i++)
#define ROF(i,a,b) for(int i=(a);i>=(b);i--)
#define MEM(x,v) memset(x,v,sizeof(x))
inline ll read(){
	char ch=getchar();ll x=0,f=0;
	while(ch<'0' || ch>'9') f|=ch=='-',ch=getchar();
	while(ch>='0' && ch<='9') x=x*10+ch-'0',ch=getchar();
	return f?-x:x;
}
struct node{
	int v,nxt1,nxt2;
};
int n,k,q,d,lstans,a[maxk][maxn],tl,len[maxk],hhh[maxn];
node b[maxk][maxn],tmp[maxn];
void build(){
	len[k]=n;
	FOR(i,1,len[k]) b[k][i]=(node){a[k][i],i,0};
	ROF(i,k-1,1){
		tl=0;
		FOR(j,1,len[i+1]) if(j%2==0) tmp[++tl]=b[i+1][j],tmp[tl].nxt2=j;
		int cur=1,cur2=1;
		FOR(j,1,n){
			while(cur<=tl && tmp[cur].v<=a[i][j]){
				tmp[cur].nxt1=j;
				b[i][++len[i]]=tmp[cur];
				cur++;
			}
			while(cur2<=len[i+1] && b[i+1][cur2].v<=a[i][j]) cur2++;
			b[i][++len[i]]=(node){a[i][j],j,cur2};
		}
		while(cur<=tl){
			tmp[cur].nxt1=n+1;
			b[i][++len[i]]=tmp[cur];
			cur++;
		}
	}
	FOR(i,1,len[1]) hhh[i]=b[1][i].v;
/*	FOR(i,1,k){
		FOR(j,1,len[i]) printf("(%d,%d,%d) ",b[i][j].v,b[i][j].nxt1,b[i][j].nxt2);
		puts("");
	}*/
}
int main(){
	n=read();k=read();q=read();d=read();
	FOR(i,1,k) FOR(j,1,n) a[i][j]=read();
	build();
	FOR(_,1,q){
		int x=read()^lstans;
//		printf("work %d\n",x);
		lstans=0;
		int p=lower_bound(hhh+1,hhh+len[1]+1,x)-hhh;
//		printf("first at %d\n",p);
		FOR(i,1,k){
			while(p<=len[i] && b[i][p].v<x) p++;
			while(p>=2 && b[i][p-1].v>=x) p--;
			if(p<=len[i]){
				lstans^=a[i][b[i][p].nxt1];
				p=b[i][p].nxt2;
			}
			else{
				p=len[i+1]+1;
			}
		}
		if(_%d==0) printf("%d\n",lstans);
	}
}