KMP算法

Posted 2021-03-13 clarencezzh

参考链接：https://www.acwing.com/solution/acwing/content/2286/

主串是”ababaeaba”,模式串是”ababacd”,在暴力算法中，遇到不匹配的情况是这样处理的:

main: "ababaeaba" // 例如这两个串，当sub为"ababae"时和"ababac"进行对
pattern: "ababacd" // 比，当main[i]为e时，发现和pattern[j]的值e不一致，暴力的做法是去下一个sub,即用"babaeab"和pattern进行比较。

暴力算法的code(时间复杂度O(N*M))

#include<iostream>

using namespace std;

const int N = 10010,M = 100010;

int n,m;
char p[N],s[M];
int ne[N];

int main()
{
    cin >> n >> p+1 >> m >> s+1;
    // BF匹配过程
    for(int i=1;i<=m;i++)
    {
        for (int j = 0,k=i; j <= n; ++j) {
            if (s[k] != p[j+1]) {
                break;
            }else {
                k++;
            }
            if (j+1==n) {
                // 匹配成功
                printf("%d ",i-1);
                break;
            }
        }
    }
    return 0;
}

　　

我没希望找到一些规律，遇到两个字符不匹配的情况时，希望可以多跳几个字符，减少比较次数。KMP算法的思想是：在模式串和主串匹配过程中，当遇到不匹配的字符时，对于主串和模式串中已对比过相同的前缀字符串，找到长度最长的相等前缀串，从而将模式串一次性滑动多位，并省略一些比较过程。在上个例子，KMP算法中，是这样处理的：

main:    "ababaeaba" // 比如main中的"ababa"子串，对标为[2~4]的"aba"和pattern中下
pattern: "ababacd"   // 标为[0~2]的"aba"相同,此时可以滑动j-k位,即j=j-k。(其中j是
                                         // pattern中"c"的下标,k是"abc"的长度)。
            "ababaeaba"      // 比较过程中，main[5]为"e"和pattern[5]为"c"不匹配，但是两个
            "ababacd"            // 串中都有相同的"aba"前缀,所以可以滑动j-k位
                    |           
                    ∨
            "ababaeaba"   
                "ababacd"
                    |               // 滑动j-k位后发现main[5]和patterb[3]不相同，需要再次滑动
                    ∨
            "ababaeaba"   
                    "ababacd" // 滑动过程和上次类似。

通过这个例子可以看出，每次滑动的位数是j-k，滑动位数和主串无关，仅通过模式串就可以求出。在KMP算法中通过next数组来存储当两个字符不相等时模式串应该移动的位数。

如何KMP算法的next数组
再次明确next数组的含义 : next数组用来存模式串中每个前缀最长的能匹配前缀子串的结尾字符的下标。 next[i] = j 表示下标以（i-j+1）为起点，i为终点的后缀和下标以1为起点，j为终点的前缀相等，且此字符串的长度最长。用符号表示为p[1~j] == p[(i-j+1)~i]，左右都使用闭区间。下面以”ababacd”模式串为例，给出这个串的next数组。

模式前缀	前缀结尾下标	最长能匹配前缀子串结尾字符的下标	next数组的取值	匹配情况
a	1	0	next[1]=0	NO
ab	2	0	next[2]=0	NO
aba	3	1	next[3]=1	pattern[1]==pattern[3]
abab	4	2	next[4]=2	pattern[3:4]==pattern[1:2]
ababa	5	3	next[5]=3	pattern[3:5]==pattern[1:3]
ababac	6	0	next[6]=0	NO
ababacd	7	0	next[7]=0	NO

KMP算法code（时间复杂度为O(N)）

#include <iostream>

using namespace std;

const int N = 10010, M = 100010;

int n, m;
int ne[N];
char s[M], p[N];

int main()
{
    cin >> n >> p + 1 >> m >> s + 1;
    // 求next数组
    //模式串长度只有大于等于2后，才开始计算next数组，只有模式串大于等于2，计算最长前缀与最长后缀
    //相等才有意义
    for (int i = 2, j = 0; i <= n; i ++ )
    {
        while (j && p[i] != p[j + 1]) j = ne[j];
        if (p[i] == p[j + 1]) j ++ ;
        ne[i] = j;
    }
//    for (int i = 1; i <=n; ++i) {
//        cout<<ne[i]<<" ";
//    }

    //匹配
    for (int i = 1, j = 0; i <= m; i ++ )
    {
        while (j && s[i] != p[j + 1]) j = ne[j];
        if (s[i] == p[j + 1]) j ++ ;
        if (j == n)
        {
            //匹配成功
            printf("%d ", i - n);
            j = ne[j];
        }
    }

    return 0;
}