P6466 分散层叠算法(Fractional Cascading)
作者：互联网
题目
思路
突然良心发现决定写下简略题意：
求x在k个有序序列里所有的后继
多次询问，强制在线
所以这题的做法显然是由裸暴力和一个预处理爆炸的算法合并得到的
裸暴力不用说，是时间
O
(
1
)
−
O
(
k
log
n
)
O(1)-O(k\log n)
O(1)−O(klogn)，空间
O
(
n
k
)
O(nk)
O(nk)的，时间炸了
预处理爆炸的，是时间
O
(
n
k
)
−
O
(
log
n
+
k
)
O(nk)-O(\log n+k)
O(nk)−O(logn+k)，空间
O
(
n
k
2
)
O(nk^2)
O(nk2)的，空间炸了
仔细思考预处理爆炸的算法：把所有序列归并到一起去，
O
(
n
k
)
O(nk)
O(nk)，对于每个大序列里的数字，下面挂k个数字，然后直接在大序列里二分，所以空间就炸了
那么我们节约一点，我们模仿信号传送的扰动，牺牲精度换取空间。（个人理解如此，可参考官方理解）
具体来说，就是Fractional Cascading算法。
我们之前的归并，是两两合并，每次合并取序列里全部的数合并，但我们现在的合并，加入扰动的因素，只取上一个合并好的序列的
1
2
1\over 2
21的元素，与现在的序列全部元素合并。
先到此打住，我们考虑一下空间复杂度，为
O
(
(
1
+
1
2
+
1
4
+
1
8
+
.
.
.
)
n
k
)
O((1+{1\over 2}+{1\over 4}+{1\over 8}+...)nk)
O((1+21+41+81+...)nk)即
O
(
n
k
)
O(nk)
O(nk)
笔者感性理解一下这个过程，好比1号要通过2,3,4,…,n号，把一个序列传递给n+1号。
这个序列就是题目中的第1个序列。
同样的，其它人也具有一个对应编号的序列。
而2号，3号以及其它人，会对序列进行扰动，即取上一个人传递的序列中偶数位的元素，与本人手中持有的序列进行归并。
这里为什么是偶数位，是因为这里取扰动程度为2（硬性要求，不能改），即取下标
m
o
d
2
=
0
\bmod~2=0
mod 2=0的元素。
n+1号不会扰动序列，但他需要完成题目要求的求后继的工作。
那么问题来了：显然序列中传递的信息是不够的，那么我们需要添加那些信息呢？即，我们需要把上文中元素所包含的意义求出来，这个意义有几个要求：
- 不能是数组，因为数组会炸内存
- 需要具有一些联系来保证单次询问实际不超过预处理爆炸算法的时间要求
联系要包括：具体数值val，即归并的数值；与上一个人扰动后的序列的对应关系，即下标nxt；本人所持实际序列的对应下标real
但是这里有一个问题：
每个人扰动后的序列，一部分来着上一个人传递的序列，一部分来着本人持有的序列
那么前者如何定义real，后者如何对应nxt呢？
考虑题目要求，我们定义real和nxt都是为了快速求解答案，而real显然是指实际序列中的后继的坐标，这可以在归并时直接求解
而后者的nxt，是为了建立上一个人扰动后的序列与本人扰动的序列的联系，那么对于当前本人扰动的序列某个元素x，其nxt应定义为上一个序列中，比x大的元素的下标。
这么说大多少都行？
显然不是的，因为这样的话nxt失去了快速求解的意义，我们要在不影响时间复杂度的情况下，使这个数尽量小
那么根据扰动程度为2，我们确定，nxt指向的这个数与x在上一个扰动后序列的后继在位置上误差不超过1，而这可以在后面询问时，不影响时间的情况下消除误差。
那么我们到这一步为止，已经彻底完成预处理，同时我们也为后面求答案做好了铺垫。
显然，预处理爆炸的做法是单次询问最快的，然而我们设计元素时又没有打算减速，所以这里的单次时间仍为
O
(
log
n
+
k
)
O(\log n+k)
O(logn+k)。
我们根据时间复杂度和元素定义，已经可以反推出算法了
首先，这个log，显然是来自裸暴力中的二分，而k可以大胆猜测确定是由nxt和n+1号的序列一步一步反向推导得到的。(显然nxt只能由后往前指)
既然是从n+1号的序列反推，显然log是二分的n+1号序列。
接下来往前推，就是从n+1号的序列，由二分获得在n号手里的实际后继，再由nxt获得n-1号干扰后序列的值，然后再考虑清除扰动，即暴力找真后继（也就是看看左边满不满足条件，右边满不满足条件）如此从n推回到1即可。
一些个人感想：
这玩意虽然难打，但是其思想是重要的，而且有一般形式，这里就不介绍了。
顺手一提，这玩意可以加强第十分块，第六分块和EI的第六分块……
反正我都不会就是了……
code：
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<iostream>
#include<cstdlib>
using namespace std;
inline int read()
{
int ret,c,f=1;
while (((c=getchar())> '9'||c< '0')&&c!='-');
if (c=='-') f=-1,ret=0;
else ret=c-'0';
while ((c=getchar())>='0'&&c<='9') ret=ret*10+c-'0';
return ret*f;
}
int n,k,q,d;
int a[110][10004],len[110],tot,tot1,tot2,lans;
struct f{
int nxt,real,val;
} b[110][20008],tmp[10004];
int get_answer(int x)
{
int l=1,r=len[k],ask=-1,ans;
while (l<=r)
{
int mid=l+r>>1;
if (b[k][mid].val>=x) ask=mid,r=mid-1;
else l=mid+1;
}
if (ask==-1) ans=0,ask=len[k];
else ans=a[k][b[k][ask].real];
int nxt=b[k][ask].nxt;
for (int i=k-1;i>=1;i--)
{
if (nxt>1&&b[i][nxt-1].val>=x) nxt--;
if (nxt<len[i]&&b[i][nxt].val<x) nxt++;
if (nxt!=len[i]||b[i][nxt].val>=x)
{
ans^=a[i][b[i][nxt].real];
}
nxt=b[i][nxt].nxt;
}
return ans;
}
int main()
{
n=read(),k=read(),q=read(),d=read();
for (int i=1;i<=k;i++)
{
for (int j=1;j<=n;j++) a[i][j]=read();
}
for (int i=1;i<=n;i++) b[1][i].val=a[1][i],b[1][i].real=i,b[1][i].nxt=0;
len[1]=n;
for (int i=2;i<=k;i++)
{
tot=0;
tot1=tot2=1;
for (int j=2;j<=len[i-1];j+=2)
{
tmp[++tot].val=b[i-1][j].val;
tmp[tot].nxt=j;
}
while (tot1<=tot&&tot2<=n)
{
if (tmp[tot1].val<a[i][tot2])
{
b[i][++len[i]]=tmp[tot1];
b[i][len[i]].real=tot2;
tot1++;
}
else
{
b[i][++len[i]].val=a[i][tot2];
b[i][len[i]].nxt=tmp[tot1].nxt;
b[i][len[i]].real=tot2;
tot2++;
}
}
while (tot1<=tot)
{
b[i][++len[i]]=tmp[tot1];
b[i][len[i]].real=tot2;
tot1++;
}
while (tot2<=n)
{
b[i][++len[i]].val=a[i][tot2];
b[i][len[i]].nxt=tmp[tot1-1].nxt;
b[i][len[i]].real=tot2;
tot2++;
}
}
for (int i=1;i<=q;i++)
{
int u=read();
u^=lans;
lans=get_answer(u);
if (i%d==0) printf("%d\n",lans);
}
return 0;
}
标签：real,nxt,nk,int,Cascading,len,Fractional,序列,P6466 来源： https://blog.csdn.net/weixin_49843717/article/details/119460993