KMP算法笔记

最新推荐文章于 2024-04-21 14:20:42 发布

LuciferPluto

最新推荐文章于 2024-04-21 14:20:42 发布

阅读量717

点赞数 5

分类专栏： ACM程序设计文章标签：数据结构算法 c++

本文链接：https://blog.csdn.net/luciferzcy/article/details/124436600

版权

ACM程序设计专栏收录该内容

3 篇文章 0 订阅

订阅专栏

KMP算法笔记

KMP算法笔记
- 由最经典的字符串匹配引入

KMP算法笔记

由最经典的字符串匹配引入

给定两个字符串A*，B，求B 是否为A* 的子串，并输出B 在A 中第一次出现的位置。(N，M<=1000000)。

输入：第一行为串A。第二行为串B。

输出：如果B 为A 的子串，输出”Yes”并输出B 在A 中第一次出现的位置；否则输出”No”

样例：

题型解析

首先想到的是暴力解法——双层for循环挨个比对，此时假设A（文本串）大小为n，B（模式串）大小为m，此时的时间复杂度为O（m*n）

但KMP算法的优势在于极大的简化了时间复杂度，——KMP在字符串匹配中极大的提高的搜索的效率。

其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。

就像一位前辈总结的那样——在当前对文本串和模式串检索的过程中，若出现了不匹配，如何充分利用已经匹配的部分

下面是对KMP算法理论解释：

KMP算法来源及应用

KMP主要应用在字符串匹配上。

KMP的主要思想是当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。

所以如何记录已经匹配的文本内容，是KMP的重点，也是next数组肩负的重任。

为了不是死记硬背代码格式，理解其中的奥妙成了必经之路，此处Pluto将结合代码随想录——Carl大佬的解释做出自己的感悟。

关键——前缀表

在KMP算法代码模板中通常有一个函数——表示了next[]数组，其实next[]数组就是一个前缀表（prefix table）。

前缀表的作用：

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

前缀表的优势：
例如：要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。

可以看出，文本串中第六个字符b 和模式串的第六个字符f，不匹配了。如果暴力匹配，会发现不匹配，此时就要从头匹配了。

但如果使用前缀表，就不会从头匹配，而是从上次已经匹配的内容开始匹配，找到了模式串中第三个字符b继续开始匹配。

由上述例子可知——前缀表的应用是在当前位置匹配失败后们可以找到之前已经匹配后的位置，并且再次重新匹配。

因此，前缀表就是——记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

所以找到最大相同前后缀是关键

最长相同前后缀

对于每一个字符串——

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

所以按照上文例子列出模式串的相同前后缀——（字符串a的最长相等前后缀为0。字符串aa的最长相等前后缀为1。字符串aaa的最长相等前后缀为2。等等…）

前缀表的计算

对于上述的计算步骤表示为：

长度为前1个字符的子串a，最长相同前后缀的长度为0
长度为前2个字符的子串aa，最长相同前后缀的长度为1。
长度为前3个字符的子串aab，最长相同前后缀的长度为0。
长度为前4个字符的子串aaba，最长相同前后缀的长度为1
长度为前5个字符的子串aabaa，最长相同前后缀的长度为2。
长度为前6个字符的子串aabaaf，最长相同前后缀的长度为0。

找到的不匹配的位置，那么此时我们要看它的前一个字符的前缀表的数值是多少

前一个字符的前缀表的数值是2，所有把下标移动到下标2的位置继续比配

前缀表与next数组

next数组就可以是前缀表，但是很多实现都是把前缀表统一减一（右移一位，初始位置为-1）之后作为next数组。两者皆可，无优劣之分

核心代码（原前缀表构造）

void getNext(int* next, const string& s){
    int j = 0;
    next[0] = 0;
    for(int i = 1; i < s.size(); i++) { // 注意i从1开始
        while (j > 0 && s[i] != s[j]) { // 前后缀不相同了
            j = next[j-1]; // 向前回退
        }
        if (s[i] == s[j]) { // 找到相同的前后缀
            j++;
        }
        next[i] = j; // 将j（前缀的长度）赋给next[i]
    }
}

解析代码

由于以下三种next[]求法，实则大同小异

直接使用前缀表当作next[]
将前缀表整体右移当作next[]
将前缀表整体-1后当作next[]

这三种会在一些细微处的处理有所区别，但大致相似——这次以方案一为例：
重点——构造next[]

定义一个函数getNext来构建next数组，函数参数为指向next数组的指针，和一个字符串。
```
void getNext(int* next, const string& s)
```
计算模式串的前缀表
- 初始化
  - 定义两个指针i和j，j指向前缀起始位置，**i指向后缀起始位置。**对next数组初始化赋值。
```
int j = 0;
next[0] = j;
```
    next[i] 表示 i（包括i）之前最长相等的前后缀长度（其实就是j）
- 处理前后缀不相同的情况
  
  因为j初始化为0，那么i就从1开始，进行s[i] 与 s[j]的比较。
  
  遍历模式串s的循环下标i 要从 1开始
  
  如果 s[i] 与 s[j]不相同，也就是遇到前后缀末尾不相同的情况，就要向前回退。
  
  回退方式：
  
  next[j]就是记录着j（包括j）之前的子串的相同前后缀的长度。
  
  那么 s[i] 与 s[j] 不相同，就要找 j前一个元素在next数组里的值（就是next[j - 1]）
```
for(int i = 1; i < s.size(); i++) {
    while (j > 0 && s[i] != s[j]) { // 前后缀不相同了
            j = next[j-1]; // 向前回退
        }
}
```
- 处理前后缀相同的情况
  
  如果s[i] 与 s[j ] 相同，那么就同时向后移动i 和j 说明找到了相同的前后缀，同时还要将j（前缀的长度）赋给next[i], 因为next[i]要记录相同前后缀的长度。
```
if (s[i] == s[j]) { // 找到相同的前后缀
    j++;
}
next[i] = j;
```
在构造next[]后，开始匹配

即找在文本串中是否有模式串出现：定义两个下标j 指向模式串起始位置，i指向文本串起始位置。
1. 那么j初始值依然为0——依然因为next数组里记录的起始位置为0。
  
  i就从1开始，遍历文本串，代码如下：

for (int i = 1; i <= s.size(); i++)

接下来就是 s[i] 与 t[j + 1] （因为j从-1开始的）进行比较。

如果 s[i] 与 t[j + 1] 不相同，j就要从next数组里寻找下一个匹配的位置。
如果j指向了模式串t的末尾，那么就说明模式串t完全匹配文本串s里的某个子串了。

则完全代码为：

class Solution {
public:
    void getNext(int* next, const string& s) {
        int j = 0;
        next[0] = 0;
        for(int i = 1; i < s.size(); i++) { // 注意i从1开始
            while (j > 0 && s[i] != s[j]) { // 前后缀不相同了
                j = next[j - 1]; // 向前回退
            }
            if (s[i] == s[j]) { // 找到相同的前后缀
                j++;
            }
            next[i] = j; // 将j（前缀的长度）赋给next[i]
        }
    }
    int strStr(string haystack, string needle) {
        if (needle.size() == 0) {
            return 0;
        }
        int next[needle.size()];
        getNext(next, needle);
        int j = 0; // // 因为next数组里记录的起始位置为-1
        for (int i = 0; i < haystack.size(); i++) { // 注意i就从0开始
            while(j > 0 && haystack[i] != needle[j]) { // 不匹配
                j = next[j - 1]; // j 寻找之前匹配的位置
            }
            if (haystack[i] == needle[j]) { // 匹配，j和i同时向后移动
                j++; // i的增加在for循环里
            }
            if (j == (needle.size() - 1) ) { // 文本串s里出现了模式串t
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }
};