一、KMP 的作用
KMP 用于解决字符串匹配问题，当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。
二、题目
链接：28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）
描述：给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
用例：
输入：haystack = “aabaabaaf”, needle = “aabaaf”
输出：3
解释：“aabaaf” 在下标 3 处匹配。第一个匹配项的下标是 3 ，所以返回 3 。
三、KMP 算法的思路
1、基本术语
先介绍一些词，后面要用：
- 文本串：上一节题目中的
haystack，比如 “aabaabaaf” - 模式串：上一节题目中的
needle，比如 “aabaaf” - 前缀：一个字符串中，包含首字母，但不包含尾字母的所有子串
- 后缀：一个字符串中，包含尾字母，但不包含首字母的所有子串
- 最长公共前后缀：一个字符串中，最长的相等的前缀和后缀。比如 “aaba” 的最长公共前后缀是 “a”，“aabaa” 的最长公共前后缀是 “aa”，“aabaaf” 不存在最长公共前后缀
- 前缀表：长度和「模式串」相同，每一位存储「模式串」对应位置及其之前所有字符所组成的字符串中，最长公共前后缀长度
2、求前缀表
原理
前缀表长度和「模式串」相同，每一位存储「模式串」对应位置及其之前所有字符所组成的字符串中，最长公共前后缀长度。比如我们用数组 next 表示前缀表，如果模式串为 “aabaaf”，那么：
next[0] = 0 ← a
next[1] = 1 ← aa
next[2] = 0 ← aab
next[3] = 1 ← aaba
next[4] = 2 ← aabaa
next[5] = 0 ← aabaaf
所以 next = {0, 1, 0, 1, 2, 0}。
代码实现
用代码实现上述过程，总体思路是：
- 用
i指向模式串后缀末尾，j指向前缀末尾 - 先处理前缀末尾不等于后缀末尾的情况（根据
next[j - 1]调整前缀末尾j的位置） - 再处理前缀末尾等于后缀末尾的情况（前缀末尾
j后移） - 最后把最长公共前后缀的长度记录在前缀表
next中
代码如下：
void getNext(int* next, string& s) {
next[0] = 0; // 只有一个字符时，无公共前后缀
int j = 0; // j 是前缀末尾的位置，同时承担着记录最长公共前后缀的职责
for (int i = 1; i < s.size(); ++i) { // i 是后缀末尾的位置，从下标 1 的位置开始
while (j > 0 && s[j] != s[i]) { // 当此时的前缀末尾字符和后缀末尾字符不相等时
j = next[j - 1]; // 调整前缀末尾的位置，原理见图 1
}
if (s[j] == s[i]) { // 当此时的前缀末尾字符等于后缀末尾字符时
++j; // 前缀末尾后移，同时由于 j 记录着公共前后缀的长度，所以长度也加 1
}
next[i] = j; // next[i] 记录前 i 个字符构成的字符串的最长公共前后缀长度
}
}
其中，代码中前缀末尾字符和后缀末尾字符不相等时的处理方法，可以结合图 1 来理解：
3、寻找匹配的字符串
在理解了求前缀表的思路后，利用前缀表去寻找匹配字符串的思路就很容易理解了，因为它们俩的思路是一样的：
- 对模式串用
getNext生成前缀表next - 用
i指向文本串haystack当前字符位置，用j指向模式串needle当前字符位置 - 先处理文本串当前字符与模式串当前字符不相等的情况（根据
next[j - 1]调整j的位置） - 再处理文本串当前字符与模式串当前字符相等的情况（
j后移） - 如果
j等于模式串长度，说明匹配成功
代码如下：
int strStr(string haystack, string needle) {
if (needle.size() > haystack.size()) // 模式串比文本串还长
return -1;
if (needle.size() == 0) // 模式串是空的
return 0;
int* next = new int[needle.size()]; // 创建动态数组
getNext(next, needle); // 根据模式串生成前缀表
int j = 0;
for (int i = 0; i < haystack.size(); ++i) {
while (j > 0 && needle[j] != haystack[i]) { // 字符不相等
j = next[j - 1]; // 调整 j 的位置
}
if (needle[j] == haystack[i]) { // j 后移
++j;
}
if (j == needle.size()) { // j 走到头了，说明匹配成功
delete [] next; // 退出前释放动态数组
return i - j + 1;
}
}
delete [] next; // 退出前释放动态数组
return -1;
}
其中文本串当前字符与模式串当前字符不相等的情况，可以结合图 2 来理解，和图 1 有许多共同之处：
完整代码：
class Solution {
public:
void getNext(int* next, string& s) {
next[0] = 0; // 只有一个字符时，无公共前后缀
int j = 0; // j 是前缀末尾的位置，同时承担着记录最长公共前后缀的职责
for (int i = 1; i < s.size(); ++i) { // i 是后缀末尾的位置，从下标 1 的位置开始
while (j > 0 && s[j] != s[i]) { // 当此时的前缀末尾字符和后缀末尾字符不相等时
j = next[j - 1]; // 调整前缀末尾的位置，原理见图 1
}
if (s[j] == s[i]) { // 当此时的前缀末尾字符等于后缀末尾字符时
++j; // 前缀末尾后移，同时由于 j 记录着公共前后缀的长度，所以长度也加 1
}
next[i] = j; // next[i] 记录前 i 个字符构成的字符串的最长公共前后缀长度
}
}
int strStr(string haystack, string needle) {
if (needle.size() > haystack.size()) // 模式串比文本串还长
return -1;
if (needle.size() == 0) // 模式串是空的
return 0;
int* next = new int[needle.size()]; // 创建动态数组
getNext(next, needle); // 根据模式串生成前缀表
int j = 0;
for (int i = 0; i < haystack.size(); ++i) {
while (j > 0 && needle[j] != haystack[i]) { // 字符不相等
j = next[j - 1]; // 调整 j 的位置
}
if (needle[j] == haystack[i]) { // j 后移
++j;
}
if (j == needle.size()) { // j 走到头了，说明匹配成功
delete [] next; // 退出前释放动态数组
return i - j + 1;
}
}
delete [] next; // 退出前释放动态数组
return -1;
}
};
使用 vector 替代动态数组：
class Solution {
public:
vector<int> getNext(string& s) {
vector<int> next(s.size());
next[0] = 0; // 只有一个字符时，无公共前后缀
int j = 0; // j 是前缀末尾的位置，同时承担着记录最长公共前后缀的职责
for (int i = 1; i < s.size(); ++i) { // i 是后缀末尾的位置，从下标 1 的位置开始
while (j > 0 && s[j] != s[i]) { // 当此时的前缀末尾字符和后缀末尾字符不相等时
j = next[j - 1]; // 调整前缀末尾的位置，原理见图 1
}
if (s[j] == s[i]) { // 当此时的前缀末尾字符等于后缀末尾字符时
++j; // 前缀末尾后移，同时由于 j 记录着公共前后缀的长度，所以长度也加 1
}
next[i] = j; // next[i] 记录前 i 个字符构成的字符串的最长公共前后缀长度
}
}
int strStr(string haystack, string needle) {
if (needle.size() > haystack.size()) // 模式串比文本串还长
return -1;
if (needle.size() == 0) // 模式串是空的
return 0;
vector<int> next = getNext(needle); // 根据模式串生成前缀表
int j = 0;
for (int i = 0; i < haystack.size(); ++i) {
while (j > 0 && needle[j] != haystack[i]) { // 字符不相等
j = next[j - 1]; // 调整 j 的位置
}
if (needle[j] == haystack[i]) { // j 后移
++j;
}
if (j == needle.size()) { // j 走到头了，说明匹配成功
return i - j + 1;
}
}
return -1;
}
};
![12.2【JAVA EXP4]next.js的各种问题，DEBUG，前端补强，前后端交互，springSecurity ,java 配置，h2数据库](https://i-blog.csdnimg.cn/direct/7582fb6ae9d7466fab308474f887d91f.png)
![[COLM 2024] V-STaR: Training Verifiers for Self-Taught Reasoners](https://i-blog.csdnimg.cn/direct/9093769bdd1647f2b28eba07a803fb5a.png)
