洛谷4696 BZOJ2384 CEOI2011 matching KMP 树状数组 离散化

题目链接

题意：
给你一个长度为$n$的排列$p$，再给你一个长度为$m$的排列$h$。对于一个序列和一个排列，我们定义这个序列能匹配这个排列的条件是，长度相同，并且序列里的元素互不相同，并且将这个排列排序后大小关系与排列的值相同。也就是说，如果排列是$p_1,p_2...p_n$，那么对$h$排序后应为$h_{p_1},h_{p_2}...h_{p_n}$。现在问$h$有多少个子串能与这个排列匹配，并且输出能匹配的子串的起始位置。$n,m<=1e6$。

题解：
感觉还是挺神的一道题，可能我现在还是理解的并不是很好。两个串的另一种意义下的匹配仍然用KMP的思路去实现。

我们考虑修改这里KMP算法中两个位置字符成功匹配的定义，原来是要求两个对应位置的字符相同，但是现在我们的要求发生了改变，我们只需要判断一个相对大小关系是不是合法就可以了。判断方法是看在它左侧已经加入的数的个数是否合法，如果合法就匹配成功并把这个数的对应位置加进去，否则我们就往前跳一次fail，并且把从原来串到fail的这些数都删去。这个过程我们用一个树状数组维护，均摊下来每个数最多被加入一次、删去一次，所以复杂度是对的。这样我们先得到一个next数组，然后用差不多的方法做匹配，但是匹配之前要先离散化一下。

这样复杂度是$O(nlogn)$的，虽然数据范围是$1e6$，但是由于这几个带$log$的操作常数都比较小，于是是可以通过这个题的。网上还有一种做法是用一个双向链表来维护的，是可以做到$O(n)$的。

代码：

#include <bits/stdc++.h>
using namespace std;

int n,m,a[1000010],b[1000010],c[1000010],s[1000010],ji[1000010],xu[1000010];
int fail[1000010],ans[1000010],cnt;
inline int read()
{
	int x=0;
	char s=getchar();
	while(s>'9'||s<'0')
	s=getchar();
	while(s>='0'&&s<='9')
	{
		x=x*10+s-'0';
		s=getchar();
	} 
	return x;
}
inline void update(int x,int y)
{
	for(int i=x;i<=m;i+=(i&(-i)))
	s[i]+=y;
}
inline int query(int x)
{
	int res=0;
	for(int i=x;i;i-=(i&(-i)))
	res+=s[i];
	return res;
}
int main()
{
	n=read();
	m=read();
	for(int i=1;i<=n;++i)
	{
		a[i]=read();
		ji[a[i]]=i;
	}
	for(int i=1;i<=n;++i)
	{
		xu[i]=query(ji[i]);
		update(ji[i],1);
	}
	memset(s,0,sizeof(s));
	for(int i=1;i<=m;++i)
	{
		b[i]=read();
		c[i]=b[i];
	}
	int i=2,j=0;
	while(i<=n)
	{
		while(query(ji[i])!=xu[j+1])
		{
			for(int k=i-j;k<i-fail[j];++k)
			update(ji[k],-1);
			j=fail[j];
		}
		++j;
		fail[i]=j;
		update(ji[i],1);
		++i;
	}
	sort(c+1,c+m+1);
	for(int i=1;i<=m;++i)
	b[i]=lower_bound(c+1,c+m+1,b[i])-c;
	memset(s,0,sizeof(s));
	i=1;
	j=0;
	while(i<=m)
	{
		while(query(b[i])!=xu[j+1]||j==n)
		{
			for(int k=i-j;k<i-fail[j];++k)
			update(b[k],-1);
			j=fail[j];
		}
		++j;
		if(j==n)
		ans[++cnt]=i-n+1;
		update(b[i],1);
		++i;
	}
	printf("%d\n",cnt);
	for(int i=1;i<=cnt;++i)
	printf("%d ",ans[i]);
	printf("\n");
	return 0;
}