KMP算法是处理字符串匹配的一种高效算法
它首先用O(m)的时间对模板进行预处理，然后用O(n）的时间完成匹配。从渐进的意义上说，这样时间复杂度已经是最好的了，需要O(m+n)时间。对KMP的学习可以为AC-自动机做铺垫，学习KMP算法的核心是要理解失配函数，比如一条状态链，其中编号为i的节点表示已经匹配了i个字符，匹配开始的状态是0，成功匹配状态是1（表示多匹配了一个字符），而失配时沿着“失配边”走。为方便起见，这里的失配函数f[i]表示状态i失配时应转移到的新状态，特别需要注意f[0]=0;
有了失配函数以后，KMP算法不难写出：
void find(char *t,char *p,int *f)
{
int n=strlen(t),m=strlen(p);
getfail(p,f);
int j=0;
for(int i=0;i<n;i++)
{
while(j&&p[j]!=t[i]) j=f[j];
if(p[j]==f[i]) j++;
if(j==m) printf("%d
",i-m+1);
}
}
总的时间复杂度为O(n)
状态转移图是构造KMP的关键也是最巧妙的地方，算法思想就是自己匹配自己，进行递推:
void getfaile(char *p,int *f)
{
int m=strlen(p);
f[0]=0;
f[1]=0;
for(int i=1;i<m;i++)
{
int j=f[i];
while(j&&p[i]!=p[j]) j=f[j];
f[i+1]=p[i]==p[j] ? j+1 : 0;
}
}求周期串类型（KMP模板题）
链接：https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1027
题解：
根据后缀函数的定义，“错位部分”长度为i-f[i]，如果这i个字符组成一个周期串，那么“错位”部分恰好是一个循环节，因此k(i-f[i])=i（注意k>1，因此i-f[i]不能等于i，必须有饭f[i]>0)
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
const int maxn=1000000+10;
int f[maxn];
string p;
int main()
{
int n,cas=0;
while(cin>>n)
{
if(n==0) break;
cin>>p;
f[0]=0;
f[1]=0;
for(int i=1;i<n;i++)
{
int j=f[i];
while(j&&p[i]!=p[j]) j=f[j];
f[i+1]=p[i]==p[j] ? j+1 : 0;
}
printf("Test case #%d
",++cas);
for(int i=2;i<=n;i++)
if(f[i]>0&&i%(i-f[i])==0)
printf("%d %d
",i,i/(i-f[i]));
cout<<endl;
}
return 0;
}
KMP裸题（求子串重复的次数） （本人poj的第50题）
链接： http://poj.org/problem?id=3461
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=1000000+10;
int f[maxn];
char p[maxn],t[maxn];
int main()
{
int k;
cin>>k;
while(k--)
{
cin>>p>>t;
int n=strlen(t),m=strlen(p);
memset(f,0,sizeof(f));
f[0]=0;
f[1]=0;
for(int i=1;i<m;i++)
{
int j=f[i];
while(j&&p[i]!=p[j]) j=f[j];
f[i+1]=p[i]==p[j] ? j+1 : 0;
}
int j=0,tt=0;
for(int i=0;i<n;i++)
{
while(j&&p[j]!=t[i]) j=f[j];
if(p[j]==t[i]) j++;
if(j==m) ++tt;
}
cout<<tt<<endl;
}
return 0;
}
KMP找出第一次出现匹配的位置：
链接：http://acm.hdu.edu.cn/showproblem.php?pid=1711
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=1000000+10;
int p[maxn],t[maxn];
int f[maxn];
int main()
{
int k;
scanf("%d",&k);
while(k--)
{
int n,m;
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++)
scanf("%d",&t[i]);
for(int i=0;i<m;i++)
scanf("%d",&p[i]);
memset(f,0,sizeof(f));
f[0]=0;
f[1]=0;
for(int i=1;i<m;i++)
{
int j=f[i];
while(j&&p[i]!=p[j]) j=f[j];
f[i+1]=p[i]==p[j] ? j+1 : 0;
}
int j=0,flag=0,tt;
for(int i=0;i<n;i++)
{
while(j&&p[j]!=t[i]) j=f[j];
if(p[j]==t[i]) j++;
if(j==m)
{
flag=1;
tt=i-m+2;
break;
}
}
if(flag==1)
printf("%d
",tt);
else
printf("-1
");
}
return 0;
}
求最短的重复串出现的次数
链接：http://poj.org/problem?id=2406
思路：KMP，next表示模式串如果第i位(设str[0]为第0位)与文本串第j位不匹配则要回到第next[i]位继续与文本串第j位匹配。则模式串第1位到next[n]与模式串第n-next[n]位到n位是匹配的。所以思路和上面一样，如果n%（n-next[n]）==0,则存在重复连续子串，长度为n-next[n]。
例如：a b a b a b
next:-1 0 0 1 2 3 4
next[n]==4,代表着，前缀abab与后缀abab相等的最长长度，这说明，ab这两个字母为一个循环节，长度=n-next[n];
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=1000000+10;
char p[maxn];
int f[maxn];
int main()
{
while(scanf("%s",p)!=EOF)
{
if(p[0]=='.') break;
int n=strlen(p);
memset(f,0,sizeof(f));
f[0]=0;
f[1]=0;
for(int i=1;i<n;i++)
{
int j=f[i];
while(j&&p[i]!=p[j]) j=f[j];
f[i+1]=p[i]==p[j] ? j+1 : 0;
}
if(n%(n-f[n])==0)
cout<<n/(n-f[n])<<endl;
else
cout<<"1"<<endl;
}
return 0;
}