[CEOI2011]Matching

最新推荐文章于 2022-02-09 10:41:49 发布

OneInDark

最新推荐文章于 2022-02-09 10:41:49 发布

阅读量228

点赞数

分类专栏： C++ 字符串数据结构文章标签：算法数据结构

本文链接：https://blog.csdn.net/qq_42101694/article/details/120086499

版权

C++ 同时被 3 个专栏收录

547 篇文章 3 订阅

订阅专栏

数据结构

137 篇文章 1 订阅

订阅专栏

字符串

38 篇文章 0 订阅

订阅专栏

本文探讨了一种使用KMP算法优化问题，将离散化序列与特定模式aaa进行匹配的高效方法。通过哈希和树状数组的传统解决方案后，作者提出利用KMP的思想，关注数字间的关系，借助值域特点设计线性时间复杂度的O(n+m)算法。

摘要由CSDN通过智能技术生成

题目

传送门 to luogu

传送门 to LOJ

思路

将 $p$ 转化一下，令 $a_{p_i}=i$ 。显然 $a$ 序列是符合 $p$ 序列的。

只要符合 $p$ 序列，那就会和 $a$ 类似。问题即，有多少个长度为 $n$ 的区间，其离散化后为 $a$ 序列。

显然我们可以考虑哈希，每次插入一个数会导致比它大的数字的离散化结果变大 $1$ ，也就是对应位置的 $base^k$ 的求和，可以用树状数组维护，删除同理，时间复杂度 $\mathcal O(m\log m)$ 。

有没有更好的做法？有。只有一个模式串、一个文本串，当然会想起 $\tt KMP$ 。此题能不能 $\tt KMP$ 呢？

$\tt KMP$ 的要点，并不在于定义相等，而是 可延展性。也就是说， $S$ 和 $T$ 匹配，等价于 $S$ 和 $T$ 同时去掉最后一个元素之后匹配，并且最后一个元素是匹配的。

在本题里，“离散化后与 $a$ 序列匹配” 并不是可延展的——最后一个元素是否加入，会影响前面的元素的离散化结果。怎么办？

稍微修改一下：当前数组离散化后，需要与 $a$ 序列 离散化 结果相同。也就是说，当前序列元素之间的大小关系，和 $a$ 序列是相同的。然后就可以 $\tt KMP$ 啦！

如何判断新加入的数的离散化情况？或许我们可以直接求出排名，但这样又需要 $\tt BIT$ 。这里就有一个不易想到的优化点了：由于 $a$ 序列的值域是 $\mathcal O(n)$ 的，考虑利用这一点求出 $a$ 序列（的所有前缀）的大小关系，然后代入当前序列检验。

$a$ 序列怎么求大小关系？而且是对于所有前缀都求一次？只需要像链表一样，求出当前数字在前缀中的前驱、后继（前缀中恰好比自己大的、恰好比自己小的），那么大小关系就明朗了。

如果当前序列的离散化结果和 $a$ 离散化结果相同，那么每个数字都要大于 $a$ 中前驱对应的数字，并且小于 $a$ 中后继对应的数字。这不仅是必要条件，更是充分条件。这样就可以做到 $\mathcal O(1)$ 判断了。

可是这东西究竟怎么求呢？显然要利用值域的特点。可以想象一下：数轴上有 $0, 1$ 两种数字，目的是求一个数字旁边第一个 $1$ ，并且可以 单向修改 将 $0$ 改为 $1$ 。这怎么做？

将过程从后往前进行，则只会把 $1$ 改成 $0$ ，询问第一个 $1$ 的位置。很像并查集，对吧？甚至比并查集更简单，因为询问一定在 $1$ 上进行，即只会询问极长连续 $0$ 子段的端点，那么将这些极长段维护下来，问题就解决了！

这是 $\mathcal O(n+m)$ 的线性做法。~~我在往这个方向思考的时候，至少想错了三次~~。

代码

#include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long int_;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
inline int readint(){
	int a = 0; char c = getchar(), f = 1;
	for(; c<'0'||c>'9'; c=getchar())
		if(c == '-') f = -f;
	for(; '0'<=c&&c<='9'; c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}
inline void writeint(int x){
	if(x < 0) putchar('-'), x = -x;
	if(x > 9) writeint(x/10);
	putchar((x-x/10*10)^48);
}

const int MaxN = 1000005;
int l[MaxN], r[MaxN], pre[MaxN], suf[MaxN];
int a[MaxN], b[MaxN], nxt[MaxN];
int ans[MaxN], tot;
int main(){
	int n = readint(), m = readint();
	rep(i,1,n){
		a[b[i] = readint()] = i;
		l[i] = i+1, r[i] = i-1;
	}
	l[0] = 1, r[n+1] = n; // boundary
	drep(i,n,1){
		/* remove a[i] from list */ ;
		int L = l[a[i]-1], R = r[a[i]+1];
		r[L] = R, l[R] = L; // only endpoint
		/* query pre and suf */ ;
		pre[i] = b[L-1], suf[i] = b[R+1];
	}
	rep(i,1,m) b[i] = readint();
	for(int j=nxt[1]=0,i=2; i<=n; ++i){
		while(j != 0){
			int x = j+1-pre[j+1];
			if(pre[j+1] && a[i] < a[i-x]){
				j = nxt[j]; continue;
			}
			x = j+1-suf[j+1];
			if(suf[j+1] && a[i] > a[i-x]){
				j = nxt[j]; continue;
			}
			++ j; break; // match
		}
		if(!j) ++ j; // 1 is always ok
		nxt[i] = j; // just like KMP
	}
	for(int j=0,i=1; i<=m; ++i){
		while(j != 0){
			int x = j+1-pre[j+1];
			if(pre[j+1] && b[i] < b[i-x]){
				j = nxt[j]; continue;
			}
			x = j+1-suf[j+1];
			if(suf[j+1] && b[i] > b[i-x]){
				j = nxt[j]; continue;
			}
			++ j; break; // match
		}
		if(!j) ++ j; // at least 1
		if(j == n){
			ans[++ tot] = i-n+1;
			j = nxt[j]; // manual
		}
	}
	writeint(tot), putchar('\n');
	rep(i,1,tot){
		writeint(ans[i]);
		putchar(' ');
	}
	putchar('\n');
	return 0;
}