数据结构---KMP算法

一、KMP算法简介

KMP算法是一个字符串匹配算法，对暴力算法BF的一种优化，使得时间复杂度大量的降低。
基本概念：

• s[]是字符串，简单来说，就是比较长的字符串。
• p[]是模式串，简单来说，就是比较短的字符串。
• ”非平凡前缀“：指除了最后一个字符以外，一个字符串的全部头部组合。
• ”非平凡后缀“：指除了第一个字符以外，一个字符串的全部尾部组合。
  下文中统称为前缀和后缀。
• ”部分匹配值“：前缀和后缀的最长共有元素的长度。
• next[]是“部分匹配值表” ，即next数组，它存放的是每一个下标对应的”部分匹配值“，KMP算法的核心。
  核心思想：
  &emsp；&emsp；在每次失配时，不是把p串往后移一位，而是把p串往后移动至下一次可以和前面部分匹配的位置，这样就可以跳过大多数的失配步骤。而每次p串移动的步数就是通过查找next[ ]数组确定的。

二、next数组及含义及手动模拟

我们先来说一下next数组的含义：
对于next[j],是p[1,j]串中前缀和后缀相同的最大长度，即最长公共前后缀。
即p[1,next[j]] == p[j - next[j] + 1, j]
示例：

手动求解next数组
对于模式串p而言（p = “abcab”）

对next[ 1 ] ：前缀 = 空集—————后缀 = 空集—————next[ 1 ] = 0;

对next[ 2 ] ：前缀 = { a }—————后缀 = { b }—————next[ 2 ] = 0;

对next[ 3 ] ：前缀 = { a , ab }—————后缀 = { c , bc}—————next[ 3 ] = 0;

对next[ 4 ] ：前缀 = { a , ab , abc }—————后缀 = { a . ca , bca }—————next[ 4 ] = 1;

对next[ 5 ] ：前缀 = { a , ab , abc , abca }————后缀 = { b , ab , cab , bcab}————next[ 5 ] = 2;

三、匹配思路和实现代码​

KMP主要分两步：求next数组、匹配字符串。个人觉得匹配操作容易懂一些，疑惑我一整天的是求next数组的思想。所以先把匹配字符串讲一下。

s串 和 p串都是从1开始的。i 从1开始，j 从0开始，每次s[ i ] 和p[ j + 1 ]比较

当匹配过程到上图所示时，
s[ a , b ] = p[ 1, j ] && s[ i ] != p[ j + 1 ] 此时要移动p串（不是移动1格，而是直接移动到下次能匹配的位置）

其中1串为[ 1, next[ j ] ]，3串为[ j - next[ j ] + 1 , j ]。由匹配可知 1串等于3串，3串等于2串。所以直接移动p串使1到3的位置即可。这个操作可由j = next[ j ]直接完成。 如此往复下去，当 j == n时匹配成功。（m为s串长度，n为p串长度）
实现代码如下：

//匹配s[i] 和 p[j + 1]进行匹配
    for(int i = 1,j = 0;i <= m;i++)
    {
        //j没有退回起点，j要是退回起点则需要重新开始匹配
        while(j && s[i] != p[j + 1])    j = ne[j];//前面不可以匹配，移动一下，保证可以匹配
        //如果j有对应p串的元素， 且s[i] != p[j+1], 则失配， 移动p串
        //用while是由于移动后可能仍然失配，所以要继续移动直到匹配或整个p串移到后面（j = 0)
        if(s[i] == p[j + 1])    j++;
        if(j == n)
        {
            
            //匹配成功了，下次重新匹配前的操作
            j = next[j];
        }
        
    }

注：采用上述的匹配方法（ i 与 j+1 比较）我不清楚（其实是想不清楚）为什么要这样。。。可能脑子有点不好使。而不推荐下标从0开始的原因我认为是：若下标从0开始的话，next[ ]数组的值都会相应-1，这就会导致它的实际含义与其定义的意思不符（部分匹配值和next数组值相差1），思维上有点违和，容易出错。（从0开始确实会复杂很多）

四、求next数组的思路及实现代码

next数组的求法是通过模板串自己与自己进行匹配操作得出来的（代码和匹配操作几乎一样）。

实现代码：

//求next数组
    //next[1] = 0,如果第一个字母失败了，那么只能从0开始
    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;
    }

代码和匹配操作的代码几乎一样，关键在于每次移动 i 前，将 i 前面已经匹配的长度记录到next数组中。

五、例题实现

//next[i]的含义表示以i为终点的后缀和从1开始的前缀相等而且后缀的长度最长
//next[i] = j
//表示p[1 , j] = p[i - j + 1 , i]

#include<iostream>

using namespace std;

const int N = 100010,M = 1000010;
int ne[N];  //next数组
int n,m;
char p[N],s[M];

int main()
{
    cin >> n >> p + 1 >> m >> s + 1;//下标从1开始
    
    //求next数组
    //next[1] = 0,如果第一个字母失败了，那么只能从0开始
    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;
    }
    
    //匹配s[i] 和 p[j + 1]进行匹配
    for(int i = 1,j = 0;i <= m;i++)
    {
        //j没有退回起点，j要是退回起点则需要重新开始匹配
        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;
}