题面
【题目描述】
近日,园长发现动物园中好吃难做的动物越来越多了。例如企鹅,只会卖萌向游客要吃的。为了整治动物园的不良风气,让动物们凭自己的真才实学向游客要吃的,园长决定开设算法班,让动物们学习算法。
某天,园长给动物们讲解
K
M
P
KMP
KMP算法。
园长:“对于一个字符串
S
S
S,它的长度为
L
L
L。我们可以在
O
(
L
)
O(L)
O(L)的时间内,求出一个名为
n
e
x
t
next
next的数组。有谁预习了
n
e
x
t
next
next数组的含义吗?”
熊猫:“对于字符串
S
S
S的前
i
i
i个字符构成的子串,既是它的后缀又是它的前缀的字符串中(它本身除外),最长的长度记作
n
e
x
t
[
i
]
next[i]
next[i]。”
园长:“非常好!那你能举个例子吗?”
熊猫:“例
S
S
S为
a
b
c
a
b
a
b
c
abcababc
abcababc,则
n
e
x
t
[
5
]
=
2
next[5]=2
next[5]=2。因为
S
S
S的前
5
5
5个字符为
a
b
c
a
b
abcab
abcab,
a
b
ab
ab既是它的后缀又是它的前缀,并且找不到一个更长的字符串满足这个性质。同理,还可得出n
e
x
t
[
1
]
=
n
e
x
t
[
2
]
=
n
e
x
t
[
3
]
=
0
,
n
e
x
t
[
4
]
=
n
e
x
t
[
6
]
=
1
,
n
e
x
t
[
7
]
=
2
,
n
e
x
t
[
8
]
=
3
。
”
ext[1] = next[2] = next[3] = 0,next[4] = next[6] = 1,next[7] = 2,next[8] = 3。”
ext[1]=next[2]=next[3]=0,next[4]=next[6]=1,next[7]=2,next[8]=3。”
园长表扬了认真预习的熊猫同学。随后,他详细讲解了如何在
O
(
L
)
O(L)
O(L)的时间内求出
n
e
x
t
next
next数组。
下课前,园长提出了一个问题:“
K
M
P
KMP
KMP算法只能求出next数组。我现在希望求出一个更强大num数组一一对于字符串S的前i个字符构成的子串,既是它的后缀同时又是它的前缀,并且该后缀与该前缀不重叠,将这种字符串的数量记作
n
u
m
[
i
]
num[i]
num[i]。例如
S
S
S为
a
a
a
a
a
aaaaa
aaaaa,则
n
u
m
[
4
]
=
2
num[4] = 2
num[4]=2。这是因为
S
S
S的前
4
4
4个字符为
a
a
a
a
aaaa
aaaa,其中
a
a
a和
a
a
aa
aa都满足性质‘既是后缀又是前缀’,同时保证这个后缀与这个前缀不重叠。而
a
a
a
aaa
aaa虽然满足性质‘既是后缀又是前缀’,但遗憾的是这个后缀与这个前缀重叠了,所以不能计算在内。同理,
n
u
m
[
1
]
=
0
,
n
u
m
[
2
]
=
n
u
m
[
3
]
=
1
,
n
u
m
[
5
]
=
2
。
num[1] = 0,num[2] = num[3] = 1,num[5] = 2。
num[1]=0,num[2]=num[3]=1,num[5]=2。”
最后,园长给出了奖励条件,第一个做对的同学奖励巧克力一盒。听了这句话,睡了一节课的企鹅立刻就醒过来了!但企鹅并不会做这道题,于是向参观动物园的你寻求帮助。你能否帮助企鹅写一个程序求出
n
u
m
num
num数组呢?
特别地,为了避免大量的输出,你不需要输出
n
u
m
[
i
]
num[i]
num[i]分别是多少,你只需要输出对
1
,
000
,
000
,
007
1,000,000,007
1,000,000,007取模的结果即可。
【输入】
第1行仅包含一个正整数
n
n
n ,表示测试数据的组数。随后n行,每行描述一组测试数据。每组测试数据仅含有一个字符串
S
S
S,
S
S
S的定义详见题目描述。数据保证$S $中仅含小写字母。输入文件中不会包含多余的空行,行末不会存在多余的空格。
【输出】
包含 n 行,每行描述一组测试数据的答案,答案的顺序应与输入数据的顺序保持一致。对于每组测试数据,仅需要输出一个整数,表示这组测试数据的答案对
1
,
000
,
000
,
007
1,000,000,007
1,000,000,007取模的结果。输出文件中不应包含多余的空行。
【样例输入】
3
aaaaa
ab
abcababc
【样例输出】
36
1
32
【提示】
n
≤
5
,
L
≤
1
,
000
,
000
n≤5,L≤1,000,000
n≤5,L≤1,000,000
算法分析
定义一个num2数组,num2[i]表示表示前i个字符是前缀又是后缀的数量,包含重叠部分。
这一个数组求解可以通过求解next时求解出来。
求解num1数组,num1[i]表示表示前i个字符是前缀又是后缀的数量,不包含重叠部分。
因为next数组前缀和后缀包含重叠部分,可以缩小前缀后缀长度,通过next数组缩小,当不存在前缀后缀重叠时,假设前缀为1~t,那么num1[i]=num2[t]+1。
参考程序
#include<bits/stdc++.h>
#define M 1000000007
#define N 1010000
using namespace std;
char s[N],p[N];
int nex[N],n,plen;
long long num2[N],num1[N];
//num2[i]表示前i个字符是前缀又是后缀的数量,包含重叠部分
//num1[i]表示前i个字符是前缀又是后缀的数量,不重叠部分
void pre()
{
int k=0;
nex[1]=0;
num2[1]=0;
plen=strlen(p+1);
for(int j=1;j<plen;j++)
{
while(k>0&&p[k+1]!=p[j+1]) k=nex[k];
if(p[k+1]==p[j+1]) k++;
nex[j+1]=k;
if(k==0) num2[j+1]=0;
else num2[j+1]=num2[k]+1;
}
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%s",p+1);
pre();
long long ans=1;
int t=0;
for(int j=1;j<plen;j++)
{
while(t>0&&p[t+1]!=p[j+1]) t=nex[t];
while(2*t+2>j+1) t=nex[t]; //找到不重叠部分
if(p[t+1]==p[j+1]) t++;
if(t==0) num1[j+1]=0;
else num1[j+1]=num2[t]+1; //+1是因为num统计的时候不包含整个串
ans=(ans*num1[j+1]+ans)%M;
}
printf("%lld\n",ans);
}
return 0;
}