[BZOJ3670][UOJ#5][NOI2014]动物园

[BZOJ3670][UOJ#5][NOI2014]动物园

试题描述

近日，园长发现动物园中好吃懒做的动物越来越多了。例如企鹅，只会卖萌向游客要吃的。为了整治动物园的不良风气，让动物们凭自己的真才实学向游客要吃的，园长决定开设算法班，让动物们学习算法。

某天，园长给动物们讲解KMP算法。

园长：“对于一个字符串S，它的长度为L。我们可以在O(L)的时间内，求出一个名为next的数组。有谁预习了next数组的含义吗？”

熊猫：“对于字符串S的前i个字符构成的子串，既是它的后缀又是它的前缀的字符串中（它本身除外），最长的长度记作next[i]。”

园长：“非常好！那你能举个例子吗？”

熊猫：“例S为abcababc，则next[5]=2。因为S的前5个字符为abcab，ab既是它的后缀又是它的前缀，并且找不到一个更长的字符串满足这个性质。同理，还可得出next[1] = next[2] = next[3] = 0，next[4] = next[6] = 1，next[7] = 2，next[8] = 3。”

园长表扬了认真预习的熊猫同学。随后，他详细讲解了如何在O(L)的时间内求出next数组。

下课前，园长提出了一个问题：“KMP算法只能求出next数组。我现在希望求出一个更强大num数组一一对于字符串S的前i个字符构成的子串，既是它的后缀同时又是它的前缀，并且该后缀与该前缀不重叠，将这种字符串的数量记作num[i]。例如S为aaaaa，则num[4] = 2。这是因为S的前4个字符为aaaa，其中a和aa都满足性质‘既是后缀又是前缀’，同时保证这个后缀与这个前缀不重叠。而aaa虽然满足性质‘既是后缀又是前缀’，但遗憾的是这个后缀与这个前缀重叠了，所以不能计算在内。同理，num[1] = 0,num[2] = num[3] = 1,num[5] = 2。”

最后，园长给出了奖励条件，第一个做对的同学奖励巧克力一盒。听了这句话，睡了一节课的企鹅立刻就醒过来了！但企鹅并不会做这道题，于是向参观动物园的你寻求帮助。你能否帮助企鹅写一个程序求出num数组呢？

特别地，为了避免大量的输出，你不需要输出num[i]分别是多少，你只需要输出对1,000,000,007取模的结果即可。

输入

第1行仅包含一个正整数n ，表示测试数据的组数。随后n行，每行描述一组测试数据。每组测试数据仅含有一个字符串S，S的定义详见题目描述。数据保证S 中仅含小写字母。输入文件中不会包含多余的空行，行末不会存在多余的空格。

输出

包含 n 行，每行描述一组测试数据的答案，答案的顺序应与输入数据的顺序保持一致。对于每组测试数据，仅需要输出一个整数，表示这组测试数据的答案对 1,000,000,007 取模的结果。输出文件中不应包含多余的空行。

输入示例1

3
aaaaa
ab
abcababc

输出示例1

36
1
32

输入示例2

传送门（点击下载）

输出示例2

传送门

数据规模及约定

n≤5,L≤1000000

题解

此题后缀数组的解法不难想到，因为找的num[i]都只考虑前缀，所以把每一个后缀和整个串匹配一下，做一下区间增加就行了。至于不能重叠的要求稍微讨论一下。

80分：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <stack>
#include <vector>
#include <queue>
#include <cstring>
#include <string>
#include <map>
#include <set>
using namespace std;

const int BufferSize = 1 << 16;
char buffer[BufferSize], *Head, *tail;
inline char Getchar() {
    if(Head == tail) {
        int l = fread(buffer, 1, BufferSize, stdin);
        tail = (Head = buffer) + l;
    }
    return *Head++;
}
int read() {
    int x = 0, f = 1; char c = Getchar();
    while(!isdigit(c)){ if(c == '-') f = -1; c = Getchar(); }
    while(isdigit(c)){ x = x * 10 + c - '0'; c = Getchar(); }
    return x * f;
}

#define maxn 1000010
#define maxlog 21
#define MOD 1000000007
#define LL long long
int n, m, rank[maxn], height[maxn], Ws[maxn], sa[maxn];
char S[maxn];

bool cmp(int* a, int p1, int p2, int len) { return a[p1] == a[p2] && a[p1+len] == a[p2+len]; }
void ssort() {
	int *x = rank, *y = height;
	m = 0; memset(Ws, 0, sizeof(Ws));
	for(int i = 1; i <= n; i++) S[i] -= ('a' - 1), Ws[x[i] = S[i]]++, m = max(m, (int)S[i]);
	for(int i = 1; i <= m; i++) Ws[i] += Ws[i-1];
	for(int i = n; i; i--) sa[Ws[x[i]]--] = i;
	for(int pos = 0, j = 1; pos < n; j <<= 1, m = pos) {
		pos = 0;
		for(int i = n - j + 1; i <= n; i++) y[++pos] = i;
		for(int i = 1; i <= n; i++) if(sa[i] > j) y[++pos] = sa[i] - j;
		for(int i = 1; i <= m; i++) Ws[i] = 0;
		for(int i = 1; i <= n; i++) Ws[x[i]]++;
		for(int i = 1; i <= m; i++) Ws[i] += Ws[i-1];
		for(int i = n; i; i--) sa[Ws[x[y[i]]]--] = y[i];
		swap(x, y); pos = 1; x[sa[1]] = 1;
		for(int i = 2; i <= n; i++) x[sa[i]] = cmp(y, sa[i], sa[i-1], j) ? pos : ++pos;
	}
	return ;
}
void calch() {
	for(int i = 1; i <= n; i++) rank[sa[i]] = i;
	for(int i = 1, j, k = 0; i <= n; height[rank[i++]] = k)
		for(k ? k-- : 0, j = sa[rank[i]-1]; S[i+k] == S[j+k]; k++) ;
	return ;
}

int minv[maxlog][maxn], Log[maxn];
void init() {
	Log[1] = 0;
	for(int i = 2; i <= n; i++) Log[i] = Log[i>>1] + 1;
	for(int i = 1; i <= n; i++) minv[0][i] = height[i];
	for(int j = 1; (1 << j) <= n; j++)
		for(int i = 1; i + (1 << j) - 1 <= n; i++)
			minv[j][i] = min(minv[j-1][i], minv[j-1][i+(1<<j-1)]);
	return ;
}
int query(int ql, int qr) {
	ql++;
	int len = qr - ql + 1, t = Log[len];
	return min(minv[t][ql], minv[t][qr-(1<<t)+1]);
}

int addv[maxn];
int main() {
	int T = read();
	while(T--) {
		n = 0; memset(S, 0, sizeof(S));
		char tc = Getchar();
		while(!isalpha(tc)) tc = Getchar();
		while(isalpha(tc)) S[++n] = tc, tc = Getchar();
		ssort();
		calch();
		init(); memset(addv, 0, sizeof(addv));
		for(int i = 2; i <= n; i++) {
			int tmp = query(min(rank[1], rank[i]), max(rank[1], rank[i]));
			tmp = min(tmp, i - 1);
//			printf("%d ", tmp);
			addv[i]++; addv[i+tmp]--;
		}
//		putchar('
');
		LL ans = 1; int t = 0;
		for(int i = 1; i <= n; i++) t += addv[i], (ans *= (1ll + t)) %= MOD;
		printf("%lld
", ans);
	}
	
	return 0;
}

此题正解是KMP，同时维护两个指针j, j2，分别表示上一次失配的位置和最后一次在位置小于等于(i >> 1)失配的位置，再维护num[i]数组表示i往前失配会经过多少条失配边。

100分：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <stack>
#include <vector>
#include <queue>
#include <cstdlib>
using namespace std;

int read() {
	int x = 0, f = 1; char c = getchar();
	while(!isdigit(c)){ if(c == '-') f = -1; c = getchar(); }
	while(isdigit(c)){ x = x * 10 + c - '0'; c = getchar(); }
	return x * f;
}

#define maxn 1000010
#define MOD 1000000007
#define LL long long
int n, f[maxn];
LL num[maxn];
char S[maxn];

int main() {
	int T = read();
	while(T--) {
		scanf("%s", S+1);
		n = strlen(S+1);
		f[1] = f[2] = 1; num[1] = 0;
		int j = 1, j2 = 1;
		LL ans = 1;
		for(int i = 2; i <= n; i++) {
			while(j > 1 && S[i] != S[j]) j = f[j];
			f[i+1] = j += (S[i] == S[j]);
			num[i] = num[f[i]] + 1;
			while(j2 > 1 && S[i] != S[j2]) j2 = f[j2];
			j2 += (S[i] == S[j2]);
			while(j2 > 1 && (j2-1 << 1) > i) j2 = f[j2];
			(ans *= (1ll + num[j2])) %= MOD;
		}
		printf("%lld
", ans);
	}
	
	return 0;
}