今天头脑风暴……然后就爆炸了!
讲字符串,图tm的坑,很难懂,然而还是可以懂。好吧也不是很难懂反正就是这样的。
=========================充满恶趣味的分割线=========================
首先来讲讲KMP这个字符串匹配中常用的方法。由于可查资料太多,不知道怎么说了~~
首先我们给出一个问题:
给出一个长度n的字符串S和一个长度m的字符串T,
问字符串T在S中出现了多少次?
这种方法用暴力来写,枚举开头位循环地找,显然时间复杂度是
O(nm)
,效率很低,而且数据稍大就会爆。那么为什么会这样呢?其实就是因为重复比较。
比如:
S:aaaaaaaaaaaaaaaaaaaaab
T:aaaaaaab
我们可以发现,在比较前面的时候,’a’是可以一直匹配下去的,直到找到T串里的’b’才会知道这次匹配不成功,显然做了很多无谓的匹配。
KMP就是处理重复比较的算法,核心思想是当匹配不成立,从下一个有可能匹配成功的地方开始比较,而不是简单的把开头推后一位。后面讲到的很多关于字符串处理的也与这个思想有关。
我们可以通过对字符串T的处理,处理出一个next数组,即当字符串T在第i位匹配失败,只需要从S的此位开始,与T的next[i]位比较即可,它的原理是:
next[i+1]表示满足
T[0..x]=T[i−x..i]
的最大的
x(0<x<i,不存在x时next[i]=0)
当T串的前i个字符匹配成功的时候,前next[i]个字符必定也是匹配成功
也就是说当T串第i个字符失配的时候,可以从T串的第next[i]个字符重新开始匹配。
以下给一个字符串处理的结果供理解。
那么next数组怎么求呢?这样求好啦~
因为我们看起来是要求在S里匹配T,那我们也可以直接在T里面匹配T~就是这样~跳到可能的位置~
以下代码W是短的字符串,即被匹配字符串。lenW表示W字符串长度
next[0]=next[1]=0;k=0;
for(int i=1;i<lenW;++i)
{
while(k && W[i]!=W[k])
k=next[k];
if(W[i]==W[k])
next[i+1]=++k;
else
next[i+1]=0;
}
我们就可以运用这个next数组来匹配:
S串每匹配一位,就检查T串的下一位能不能匹配,如果不能匹配就跳到T串相应的next位置开始匹配,如此直到可以匹配或者T串被迫从头开始匹配为止。
just like this:
其中T是匹配串……
k=ans=0;
for(int i=0;i<lenT;++i)
{
while(k && T[i]!=W[k])
k=next[k];
if(T[i]==W[k])
++k;
if(k==lenW)
{
++ans;
k=next[k];
}
}
时间复杂度分析:
在算法中,S的匹配位置前进n次,k值因此能够增加n,而通过next数组回退一次,k至少减少1,因此最多回退n次,且前进和回退的耗时均为常数。
因此匹配部分时间复杂度为O(n)
同理可得预处理部分时间复杂度O(m)
总的时间复杂度为O(n+m)
===========================鬼畜的分割线===========================
然后讲了传说中的manacher算法……处理回文串用到的东西哦。
那么问题来了:
挖掘机技术哪家强
给定一个长度为n字符串S,现在要从中找出一个回文的子串T。字符串A是回文的,当且仅当A反转后的A’和A完全相等。问T可能的最大长度。
暴力方法大家都懂的,枚举开始枚举长度一位位搜咯, O(n) 而已嘛~
好吧,其实我首先想到的方法是根据回文串的特性,枚举每个回文串的中点,这样就可以直接往两边找就好啦,时间
O(n2)
,然而遇到偶数长度的回文串并不能处理。
就把它转成奇数就好啦~,在每两个字符之间加一个没出现过的字符,然后再加一头一位两个不同字符作终止,就好啦-.-。
比如原串abba
——>
@#a#b#b#a#%
这样就可以啦。要注意找回文串时是可以从’#’开始找的,不需要跳过,这样整个回文串的长度就是找出来的半径减一就好啦(你懂的)。
然而这并不是重点,我们要更快啊!
想到之前的KMP是可以通过已知求未知,我们的manacher算法也是如此,通过先前已经求过的回文串的长度来求当前为中心的最长回文串。
举个栗子:
S: caaabaaaaabaaac
ans:1131713F31? (以该位置为中心的答案)
我们可以通过S[8]中心处的答案得到S[1..15]’=S[1..15],又通过S[5]中心处得到S[2..8]’=S[2..8],我们可以推得S[11]中心处的答案。
即:
∵S[1..15]’=S[1..15]’ ∴S[2..8]’=S[8..14]
∵S[1..15]’=S[1..15]’ ∴S[2..8]=S[8..14]’
又∵S[2..8]=S[2..8]’
∴S[8..14]=S[2..8]’=S[2..8]=S[8..14]’
也就是说S[11]中心处答案至少为7,?>=7
比较S[7]和S[15],发现S[7]!=S[15]
因此?<9,故S[11]中心处的答案是7
为什么可以这样做呢?实际上是用了回文串的特性,没错就是对称了。我们可以设前面所有找到的回文串中,能延伸最右的回文串其中心下标为p,其回文串长度为ans[p],当前要求点为i,i关于p对称点为i’,当然显然i’=2*p-i。则有两种情况:
可以看出,此时p+ans[p]大于(等于)i+ans[i],所以以i为中心的回文字串显然是被涵盖在以p为中心的回文字串中的,根据回文串的特性,前面已经求出ans[i’]的值,那么ans[i]=ans[i’]。
此时p+ans[p]小于i+ans[i],所以以i为中心的回文字串显然是不被涵盖在以p为中心的回文字串中的,根据回文串的特性,前面已经求出ans[i’]的值,但我们智能知道[i+i-max..max]这一段是成立的回文串,再往后我们没有依据,所以只能搜索下去。
这就是manacher算法的总体思路。
贴代码咯~
首先你要有一段change,处理偶数情况,当然是都适用的:
void change()
{
len=strlen(S);
for(int i=len-1;i>=0;--i)
{
S[i*2+2]=S[i];
S[i*2+1]='#';
}
S[len*2+1]='#';
S[0]='@';S[len*2+2]='$';
len*=2;
}
其中我上面写的len是指不包括两端特殊字符的长度哦~也就是S[1..len]={#a#b#b#..#a#}这样子的。
接下来还要有一段manacher核心代码:
void manacher()
{
memset(ans,0,sizeof(ans));
ans[0]=ans[1]=0;p=1;
for(int i=2;i<=len;++i)
{
ans[i]=max(0, min(ans[2*p-i],p+ans[p]-i) );
while (S[i-ans[i]]==S[i+ans[i]])
ans[i]++;
if(i+ans[i]>p+ans[p])
p=i;
}
realans=0;
for(int i=2;i<=len;++i)
realans=max(ans[i],realans);
printf("%d\n",realans-1);
}
时间复杂度:
这个算法while部分每运行一次,p的最右端就向右移动最少一格,然而最右端最多只能移动n格,因此while部分最多执行循环n次,再加上其他部分随着for循环最多执行n次(n均计算字符串被改后的长度),总的时间复杂度为
O(n)
。
好的以上就是manacher算法的内容~
============================偶然来到这个世界的分割线============================
接下来是扩展KMP~还是先丢出一个问题:
给出一个长度n的字符串S[0..n-1],和一个长度m的字符串T[0..n-1],问S的哪个后缀和T具有最长的公共前缀。
暴力显然是 O(nm) 的,但我们要与重复运算作斗争!
首先我们可以试着和kmp一样的思路:
先假设T的每一个后缀T[i..n-1]和T[0..n-1]本身的的最长公共前缀用数组next[i]存储,特别的next[0]=n
然后设答案伸得最远的后缀(不包括原串)为T[p..n-1],如果其公共前缀没有包含字符T[i],就暴力求next[i](i=1时也暴力求),否则可以像manacher一样直接拿现成结果
比如:
S :aaaabaaaa
ans:932104?
已知:S[0..3]=S[5..8]和S[1..3]=S[0..2]
S[0..3]=S[5..8] -> S[1..3]=S[6..8]
故S[6..8]=S[1..3]=S[0..2]
因此ans[6]至少为3
此时我们检查ans[6]能否更大
S[9]!=S[3],因此ans[6]就是3
好吧,由于我自己讲的不算很清,我觉定转载一下哦~
============================以下内容转自ACMer的博客~~============================
- 拓展kmp算法一般步骤
通过上面的例子,事实上已经体现了拓展kmp算法的思想,下面来描述拓展kmp算法的一般步骤。
首先我们从左到右依次计算extend数组,在某一时刻,设extend[0…k]已经计算完毕,并且之前匹配过程中所达到的最远位置为P,所谓最远位置,严格来说就是i+extend[i]-1的最大值 (0<=i<=k) ,并且设取这个最大值的位置为po,如在上一个例子中,计算extend[1]时,P=3,po=0。
现在要计算extend[k+1],根据extend数组的定义,可以推断出S[po,P]=T[0,P-po],从而得到 S[k+1,P]=T[k-po+1,P-po],令len=next[k-po+1],(回忆下next数组的定义),分两种情况讨论:
第一种情况:
k+len<P
如下图所示:
上图中,S[k+1,k+len]=T[0,len-1],然后S[k+len+1]一定不等于T[len],因为如果它们相等,则有S[k+1,k+len+1]=T[k+po+1,k+po+len+1]=T[0,len],那么next[k+po+1]=len+1,这和next数组的定义不符(next[i]表示T[i,m-1]和T的最长公共前缀长度),所以在这种情况下,不用进行任何匹配,就知道extend[k+1]=len。
第二种情况:
k+len>=P
如下图:
上图中,S[p+1]之后的字符都是未知的,也就是还未进行过匹配的字符串,所以在这种情况下,就要从S[P+1]和T[P-k+1]开始一一匹配,直到发生失配为止,当匹配完成后,如果得到的extend[k+1]+(k+1)大于P则要更新未知P和po。
至此,拓展kmp算法的过程已经描述完成,细心地读者可能会发现,next数组是如何计算还没有进行说明,事实上,计算next数组的过程和计算extend[i]的过程完全一样,将它看成是以T为母串,T为字串的特殊的拓展kmp算法匹配就可以了,计算过程中的next数组全是已经计算过的,所以按照上述介绍的算法计算next数组即可,这里不再赘述。
============================以上内容转自ACMer的博客~~============================
好啦,接下来是贴代码时间哦~
首先是next数组的时间:
void get_NEXT()
{
NEXT[0]=len2;
int i=0,j,p,u;
while(S[i]==S[i+1]&&i+1<len2)
++i;
NEXT[1]=i;
p=1;
for(i=2;i<len2;++i)
{
u=p+NEXT[p];
if(i+NEXT[i-p]<u)
NEXT[i]=NEXT[i-p];
else
{
j=max(NEXT[p]+p-i,0);
while(i+j<len&&S[j]==S[j+i])
j++;
NEXT[i]=j;p=i;
}
}
}
然后是恩主步骤哦~
void EXKMP()
{
int i,j,p,u;
ex[0]=len2;p=0;
for(i=1;i<len;++i)
{
u=p+ex[p];
if(i+NEXT[i-p]<u)
ex[i]=NEXT[i-p];
else
{
j=ex[p]+p-i;
if(j<0)j=0;
while(i+j<len&&j<len2&&S[j+i]==S[j])
j++;
ex[i]=j;p=i;
}
}
}
时间复杂度分析:
第一步求next时内层for循环每执行一次,p至少伸长一格,因此内层for循环至多循环m次,加上外层for循环其余语句,可得时间复杂度O(m)
第二步求ex时同理O(n)
总的时间复杂度O(m+n)
完结撒花~~~~