[2018.10.17校内训练] 小报告 KMP+主席树

题面

给定一个长度为$n$的序列和一个长度为$m$的序列，问长度为$n$的序列中有多少个长度为$m$的子串离散化后的结果恰好为原先给的长度为$m$的序列，并求出出现的位置。
$n,m\le 10^5$

解法

表示这道题yy了很久……KMP可以和主席树放在一起考察比较诡异……
考试的时候并没有理解这个为什么是正确的，回家想想似乎确实很对……
给这道题好评！难度适中，覆盖知识点广，题目有着切合实际的背景，解法比较自然。

• 看到要求出现的位置，第一感应该是字符串哈希或者是KMP。但是发现字符串哈希并不是特别好写，所以就考虑如何用KMP来实现。
• 可以发现，求解$next$数组的时候和匹配的时候其实是一样的，只要解决一个问题：如何定义两个字符是相同的？？
• 假设我们现在要求解$next[i]$，那么我们会枚举到一个点$j$，如果$a[j+1]$和$a[i]$在我们的定义下是相同的，那么$next[i]=j+1$，否则$j$就一直变成$next[j]$。
• 考虑长度为$j+1$的前缀和以$i$结尾的长度为$j+1$的后缀，既然长度为$j$的部分一定是相同的，那么我们如果重新加入一个数且能够一一对应，那么显然这两个字符串也一定相同。那么我们只要求出$a[i]$在对应这段后缀中的具体排名和和它相同的数有多少个，$a[j+1]$同理，如果这两个东西对应相同，那么我们一定可以认为这两个字符串是相同的，否则这两个字符串一定不同。
• 考虑这个算法为什么是正确的，因为前面的部分是一定相同的，那么新加入一个数并不会影响前面部分离散化后的对应关系，我们只要看新加入的两个字符是否能对应得上就可以了，“能对应上”的条件如上文所述。
• 那么现在我们只要求出一段区间中严格小于和非严格小于某一个数的数的个数，直接主席树处理即可。
• 时间复杂度：$O(n\log n)$

代码

#include <bits/stdc++.h>
#define N 100010
using namespace std;
template <typename node> void read(node &x) {
	x = 0; int f = 1; char c = getchar();
	while (!isdigit(c)) {if (c == '-') f = -1; c = getchar();}
	while (isdigit(c)) x = x * 10 + c - '0', c = getchar(); x *= f;
}
struct SegmentTree {
	struct Node {int lc, rc, cnt;} t[N * 35];
	int tot;
	int ins(int k, int l, int r, int x) {
		int ret = ++tot; t[ret] = t[k]; t[ret].cnt++;
		if (l == r) return ret; int mid = (l + r) >> 1;
		if (x <= mid) t[ret].lc = ins(t[k].lc, l, mid, x);
			else t[ret].rc = ins(t[k].rc, mid + 1, r, x);
		return ret;
	}
	int query(int k1, int k2, int l, int r, int x) {
		if (l == r) return t[k2].cnt - t[k1].cnt;
		int mid = (l + r) >> 1;
		if (x <= mid) return query(t[k1].lc, t[k2].lc, l, mid, x);
		return t[t[k2].lc].cnt - t[t[k1].lc].cnt + query(t[k1].rc, t[k2].rc, mid + 1, r, x);
	}
} A, B;
int n, m, a[N], b[N], c[N], d[N], Rt[N], rt[N], nxt[N], ans[N];
bool Same(int j, int i) {
	int x = B.query(0, Rt[j + 1], 0, m, b[j + 1] - 1) == B.query(Rt[i - j - 1], Rt[i], 0, m, b[i] - 1);
	int y = B.query(0, Rt[j + 1], 0, m, b[j + 1]) == B.query(Rt[i - j - 1], Rt[i], 0, m, b[i]);
	return x && y;
}
void getnxt() {
	for (int i = 2; i <= m; i++) {
		int j = nxt[i - 1];
		while (j && !Same(j, i)) j = nxt[j];
		if (Same(j, i)) j++; nxt[i] = j;
	}
}
bool same(int j, int i) {
	int x = B.query(0, Rt[j + 1], 0, m, b[j + 1] - 1) == A.query(rt[i - j - 1], rt[i], 0, n, a[i] - 1);
	int y = B.query(0, Rt[j + 1], 0, m, b[j + 1]) == A.query(rt[i - j - 1], rt[i], 0, n, a[i]);
	return x && y;
}
int main() {
	freopen("message.in", "r", stdin);
	freopen("message.out", "w", stdout);
	read(n), read(m);
	for (int i = 1; i <= n; i++) read(a[i]), c[i] = a[i];
	for (int i = 1; i <= m; i++) read(b[i]);
	for (int i = 1; i <= m; i++) Rt[i] = B.ins(Rt[i - 1], 0, m, b[i]);
	getnxt(); sort(c + 1, c + n + 1);
	int tmp = unique(c + 1, c + n + 1) - c - 1;
	map <int, int> h;
	for (int i = 1; i <= tmp; i++) h[c[i]] = i;
	for (int i = 1; i <= n; i++) a[i] = h[a[i]];
	for (int i = 1; i <= n; i++) rt[i] = A.ins(rt[i - 1], 0, n, a[i]);
	int len = 0;
	for (int i = 1, j = 0; i <= n; i++) {
		while (j && !same(j, i)) j = nxt[j];
		if (same(j, i)) j++;
		if (j == m) ans[++len] = i - j + 1, j = nxt[j];
	}
	printf("%d\n", len);
	for (int i = 1; i <= len; i++) printf("%d\n", ans[i]);
	return 0;
}