KMP算法在字符串中的应用

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\n",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\n",++cas);
        for(int i=2;i<=n;i++)
            if(f[i]>0&&i%(i-f[i])==0)
            printf("%d %d\n",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\n",tt);
        else
            printf("-1\n");
    }
    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;
}