KMP算法：计算三种next数组

        KMP算法是一种改进的字符串匹配算法，由D.E.Knuth、J.H.Morris和V.R.Pratt提出，因此也被称为克努特—莫里斯—普拉特操作（简称KMP算法）。KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现是通过一个next数组实现，函数本身包含了模式串的局部匹配信息。KMP算法的时间复杂度为O(m+n)，其中m为模式串的长度，n为主串的长度。相较于暴力算法，KMP算法在处理长字符串时具有更高的效率。

朴素版匹配算法

        朴素版字符串匹配算法用两个指针分别指向两个字符串，当匹配成功时同时向后移动，匹配失败让模式串向后移动如下图所示。也就是说开始时匹配的是主串s中1~t.size()如果失败就匹配2~t.size()+1…直到模式串在主串中找到相同的子字符串或指针 i 的下标大于s.size()-t.size()为止。

        通过双重循环遍历两个字符串，如果匹配失败就跳出内循环让模式串向右移动。代码的时间复杂度与单循环while一样为O(N*M)。

int Index(string s, string t)
{
	for (int i = 0; i < s.size() - t.size(); i++)
		for (int j = 0; j < t.size(); j++)
		{
			if (s[i + j] != t[j])	break;
			else if (j == t.size() - 1)	return i - t.size();
		}

	return -1;
}

KMP算法

        KMP算法的核心是求next数组，next数组可以认为是给字符串加密，后序的匹配相当于解密，两者代码类似。在网络上next数组有三种求法，分别在《数据结构》严蔚敏版、《算法导论》以及手算next值中上遇到，为了方便下文以1~3来区分它们的关系。

第一种next数组求法

        首先看下面这个例子（1），当字符串匹配失败时，如果按照朴素版的话，模式串后移且两个指针初始化如（2）所示。但仔细观察模式串可以发现，绿框表示的是两个子字符串是相同的，那么只要将头子字符串直接移到 j 指针之前，那么依然能保证 j 指针前的字符串是匹配度如（3）所示。对照两者的区别可以发现，其中 i 指针是保持不变的，j 指针通过回溯去寻找相同的首字符串，通过这种思想做到了主串不回溯，时间复杂度可以大幅度降低至O(N+M)。

        对于如何让指针回溯的适合的位置，需要一个辅助数组next，next存放的是两字符串匹配时发生错误后指针 j 跳转的位置也就是态（1）转移到状态（3）。在计算next值之前，首先需要默认模式串从数组下标1开始存储，同样的next数组与存储数组相对应也是从1开始计算赋值为0。因为第一个字符如果匹配失败j指着跳转到0出也相当于模式串右移，下标0是用来判断没有匹配到的字符。如上模式串中的第一个C，虽然没有首字符串与它匹配，但是依然需要对它进行赋值，以便指针 j 匹配失败后制动到第一个字符的位置。匹配代码如下所示。

void get_next()
{
    for (int l = 0, r = 1; r < n;)
    {
        if (l == 0 || s[r] == s[l])
        {
            l ++, r ++;
            ne[r] = l;
        }
        else    l = ne[l];
    }
}

        根据上述代码模拟出模式串求next数组的过程，这个过程类似于模式串自己对自己进行KMP匹配，R指针之前是的next值都已经求出来了，因此右指针R指向的字符即使找不到匹配的字符，也可以让左指针回到0处赋值。

--------------------------------------------------------PPT画不下了------------------------------------------------------

         最后模式串和主串匹配的代码和过程如下所示，按照《数据结构》严蔚敏版的代码，当发现匹配成功后就直接结束，但主串中可能存在多个模式串，本代码为修改并测试AC，题目要求返回值从0开始因此参数-1。当模式串匹配完成后，LR指针都指向了字符串外，因此如果需要在此进行匹配序列，那么两个指针都需要回到字符串末字符，让模式串根据next值回溯。

void index_KMP()
{
    int l = 1, r = 1;
    while (r <= m)
    {
        if (l == 0 || s[l] == t[r]) l ++, r ++;
        else    l = ne[l];
        
        if (l > n)
        {
            printf("%d ", r - n - 1);
            l --, r --;
            l = ne[l];
        }
    }
}

        由于之前的样例参考《数据结构》，主串只存在一个模式串，因此直击拷贝书上的匹配过程，完整代码在最后。 

第二种next数组求法

        第一种next数组是存储回溯位置，在《算法导论》中提供了另一种next求法，next数组中存储的是最大的首字符串长度。如下代码所示，同样的从下标1开始存储，0为没有匹配字符，这里比较的是L+1和R的关系，当L+1与R不匹配返回让L继续回溯。当回溯完后还需要让L+1和R进行比较，因为可能原本字符匹配失败，但在回溯后匹配成功了。

void get_next()
{
    for (int l = 0, r = 2; r <= n; r ++ )
    {
        while (l != 0 && s[l + 1] != s[r])    l = ne[l];
        if (s[l + 1] == s[r])    l ++;
        ne[r] = l;
    }
}

         同样的对模式串进行模拟这里就不在赘述了，如下图所示。

         由于第二种KMP算法从始至终比较的都是L+1，回溯的是L，因此即使两个字符串匹配完成后，L和R指针依然指向两个字符串末字符，因此没必要确定位置，直接让L进行回溯即可。至于匹配过程，与上述匹配大同小异，需要额外注意L+1指针。

void index_KMP()
{
    for (int l = 0, r = 1; r <= m; r ++ )    //m为主串t的长度
    {
        while (l != 0 && s[l + 1] != t[r])  l = ne[l];
        if (s[l + 1] == t[r]) l ++;
        if (l == n)    //可能存在多匹配成功
        {
            printf("%d ", r - n);
            l = ne[l];
        }
    }
}

第三种next数组求法

        这种在做题目是遇到需要手算next值，只要让第一种方式求出来的next值每一个都减1即可。

来自2024王道数据结构题P115第6题：

串“ababaaababaa”的next数组为（）

A、-1,0,1,2,3,4,5,6,7,8,8,8        B、-1,0,1,0,1,0,0,0,0,1,0,1

C、-1,0,0,1,2,3,1,1,2,3,4,5        D、-1,0,1,2,-1,0,1,0,1,2,1,1,2,3

按照第一种next数组求法结果为0 1 1 2 3 4 2 2 3 4 5 6，让每一个数都-1正好为答案：C

优化KMP算法

        在处理一些特殊的字符时，KMP算法还可以继续优化。如下案例，当模式串匹配遇到失败时，按照第一种匹配使得模式串后移一位。原本b！=a，在回溯后依然是b！=a……如果按照nextval数组，可以做到一步到位。

         与原先的求next数组一样，nextval代码进行了两次比较，让后序的字符下标等于最初的下标，也就是上述的下标2~4全部都等于下标1的值。

void get_nextval()
{
	for (int l = 0, r = 1; r < n;)
	{
		if (l == 0 || s[l] == s[r])
		{
			l++, r++;
			if (s[l] != s[r])	nextval[r] = l;
			else nextval[r] = nextval[l];
		}
		else	l = nextval[l];
	}
}

         这个过程类似于并查集的路径压缩，在并查集里，两个元素是否在同一个集合只要找是否有公共祖先，因此将路径全都压缩至1，而nextval中第二次比较也类似于这一步的路径压缩。

前两者KMP算法AC代码

第一种KMP算法完整代码

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1000010;

int n, m;
char s[N], t[N];
int ne[N];

void get_next()
{
    for (int l = 0, r = 1; r < n;)
    {
        if (l == 0 || s[r] == s[l])
        {
            l ++, r ++;
            ne[r] = l;
        }
        else    l = ne[l];
    }
}

void index_KMP()
{
    int l = 1, r = 1;
    while (r <= m)
    {
        if (l == 0 || s[l] == t[r]) l ++, r ++;
        else    l = ne[l];
        
        if (l > n)
        {
            printf("%d ", r - n - 1);
            l --, r --;
            l = ne[l];
        }
    }
}

int main()
{
    cin >> n >> s + 1 >> m >> t + 1;
    
    get_next();
    index_KMP();
    
    return 0;
}

 第二种KMP算法完整代码

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1000010;

int n, m;
char s[N], t[N];
int ne[N];

void get_next()
{
    for (int l = 0, r = 2; r <= n; r ++ )  //遍历匹配字符串
    {
        while (l != 0 && s[l + 1] != s[r])    l = ne[l];
        if (s[l + 1] == s[r])    l ++;
        ne[r] = l;
    }
}

void index_KMP()
{
    for (int l = 0, r = 1; r <= m; r ++ )
    {
        while (l != 0 && s[l + 1] != t[r])  l = ne[l];
        if (s[l + 1] == t[r]) l ++;
        if (l == n)
        {
            printf("%d ", r - n);
            l = ne[l];
        }
    }
}

int main()
{
    cin >> n >> s + 1 >> m >> t + 1;
    
    get_next();
    index_KMP();
    
    return 0;
}