KMP算法

前缀表

前缀表（prefix table) ：前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。

前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。

后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。

而前缀表内存储的是最长相等前后缀（这里我们定义它为next数组）

如何计算前后缀

比如aadaaf:

a                前缀：                 后缀：                       0

aa              前缀：a               后缀： a                    1

aad            前缀：a               后缀： d                    

                  前缀：aa             后缀： ad                  0  

aada          前缀：a               后缀： a                    1

                  前缀：aa              后缀： da  

                  前缀：aad            后缀： ada  

aadaa        前缀：a                后缀： a                     2

                  前缀：aa              后缀： aa

                  前缀：aad            后缀： daa

                  前缀：aada          后缀： adaa

aadaaf       前缀：a                后缀： f                     0（后缀一直存在f,所以前后缀不会相等，这里就不列举了）

所以这里next = [0, 1, 0, 1, 2,0]

模式串和next数组的关系

next数组的长度和模式串的长度是相等的，用 i 指向模式串，next数组就是表示 i 之前的子串（包括 i ），有多少相等的前后缀。

KMP算法的原理

假如计算文本串匹配模式串的下表，例如. - 力扣（LeetCode）。

第一想到是暴力，时间复杂度是O（M * N），如果使用KMP，时间复杂度是O（M + N)

KMP的使用流程：比如文本串是aabaabaafa, 模式串为aabaaf。

1、模式串去匹配文本串，到了文本串下标5（'b') （模式串字符是 'f' ) 位置就不匹配了

2、去找 'f' 对应的前一个next数组的下标，这里是next[4] = 2。

3、找到的这个值（next[4] = 2），代表模式串要跳到下标2处去再次匹配文本串。（模式串 'b' )

这就是KMP算法的原理

如何求next数组

求解next数组主要是三步：

1. 初始化
2. 处理前后缀不相同的情况
3. 处理前后缀相同的情况

1.初始化

j = 0  # j 表示后缀末尾，也是最长相等前后缀
next[0] = 0

2.前后缀不相等 

while j > 0 and s[i] != s[j]:
    j = next[j - 1]  # 这里也是KMP算法的原理，遇到不相等的前后缀，j 跳到上一个已经next元素。

3.相等 

if s[i] == s[j]:
    j += 1

 整体代码：

def getNext(self, next: List[int], s: str) -> None:
    j = 0
    next[0] = 0
    for i in range(1, len(s)):
        while j > 0 and s[i] != s[j]:
            j = next[j - 1]
        if s[i] == s[j]:
            j += 1
        next[i] = j

其实求解next数组本质上是递推的过程，比如aadaaf，j = 0 和next[0] = 0，i 从1开始，这样s[i] 和s[j]才能比较。判断不相等的情况必须在相等情况之前 。