Update

2025-07-06 23:28:29 +08:00 · 2020-09-10 11:48:19 +08:00
parent 15261056fd
commit a5f66508a1
6 changed files with 320 additions and 34 deletions
--- a/README.md
+++ b/README.md
@ -55,6 +55,7 @@
 * [字符串：都来看看KMP的看家本领！](https://mp.weixin.qq.com/s/Gk9FKZ9_FSWLEkdGrkecyg)
 * [字符串：听说你对KMP有这些疑问？](https://mp.weixin.qq.com/s/mqx6IM2AO4kLZwvXdPtEeQ)
 * [字符串：KMP算法还能干这个！](https://mp.weixin.qq.com/s/lR2JPtsQSR2I_9yHbBmBuQ)
+* [字符串：前缀表不右移，难道就写不出KMP了？](https://mp.weixin.qq.com/s/p3hXynQM2RRROK5c6X7xfw)

 （持续更新中....）

--- a/pics/40.组合总和II.png
+++ b/pics/40.组合总和II.png
--- a/problems/0028.实现strStr().md
+++ b/problems/0028.实现strStr().md
@ -29,9 +29,178 @@ https://leetcode-cn.com/problems/implement-strstr/

 KMP的经典思想就是:**当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配。**

-如果对KMP理论基础还不够了解的同学请看[字符串：KMP是时候上场了（一文读懂系列）](https://mp.weixin.qq.com/s/70OXnZ4Ez29CKRrUpVJmug)。 
+本篇将以如下顺序来讲解KMP，

-**为了和[字符串：KMP是时候上场了（一文读懂系列）](https://mp.weixin.qq.com/s/70OXnZ4Ez29CKRrUpVJmug)字符串命名统一，方便大家理解，以下文章统称haystack为文本串, needle为模式串。**
+1. 什么是KMP
+2. KMP可以解决什么问题
+3. 分析KMP算法里的next数组
+4. 什么是前缀表
+5. 再分析为什么要是前缀表而不是什么哈希表其他表等等，偏偏要是前缀表。
+6. 一步一步推导前缀表是怎么求的
+7. 时间复杂度分析
+8. 前缀表与next数组的关系
+9. 如何使用next数组来做一遍匹配的过程
+10. 构造next数组 
+11. 使用next数组进行匹配 
+12. 前缀表统一减一（右移）的KMP实现方式
+13. 前缀表不减一的KMP实现方式
+14. 总结
+
+可以说步步相扣，大家要跟紧，哈哈。
+
+# 什么是KMP
+
+说到KMP，先说一下KMP这个名字是怎么来的，为什么叫做KMP呢。
+
+因为是由这三位学者发明的：Knuth，Morris和Pratt，所以取了三位学者名字的首字母。所以叫做KMP
+
+# KMP有什么用
+
+KMP主要应用在字符串匹配上。
+
+KMP的主要思想是**当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。**
+
+所以如何记录已经匹配的文本内容，是KMP的重点，也是next数组肩负的重任。
+
+其实KMP的代码不好理解，一些同学甚至直接把KMP代码的模板背下来。
+
+没有彻底搞懂，懵懵懂懂就把代码背下来太容易忘了。
+
+不仅面试的时候可能写不出来，如果面试官问：**next数组里的数字表示的是什么，为什么这么表示？**
+
+估计大多数候选人都是懵逼的。
+
+下面Carl就带大家把KMP的精髓，next数组弄清楚。
+
+# 什么是前缀表
+
+写过KMP的同学，一定都写过next数组，那么这个next数组究竟是个啥呢？
+
+next数组就是一个前缀表（prefix table）。
+
+前缀表有什么作用呢？
+
+**前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。**
+
+为了清楚的了解前缀表的来历，我们来举一个例子：
+
+要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。
+
+请记住文本串和模式串的作用，对于理解下文很重要，要不然容易看懵。所以说三遍：
+
+要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。
+
+要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。
+
+要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。
+
+如动画所示：
+
+<img src='../../media/video/KMP精讲1.gif' width=600> </img></div>
+
+动画里，我特意把 子串`aa` 标记上了，这是有原因的，大家先注意一下，后面还会说道。
+
+可以看出，文本串中第六个字符b 和 模式串的第六个字符f，不匹配了。如果暴力匹配，会发现不匹配，此时就要从头匹配了。
+
+但如果使用前缀表，就不会从头匹配，而是从上次已经匹配的内容开始匹配，找到了模式串中第三个字符b继续开始匹配。
+
+此时就要问了**前缀表是如何记录的呢？**
+
+首先要知道前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，在重新匹配，此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。
+
+那么什么是前缀表：**记录下表i之前（包括i）的字符串中，有多大长度的相同前缀后缀。**
+
+# 为什么一定要用前缀表
+
+这就是前缀表那为啥就能告诉我们 上次匹配的位置，并跳过去呢？
+
+回顾一下，刚刚匹配的过程在下表5的地方遇到不匹配，模式串是指向f，如图：
+<img src='../../media/pics/KMP精讲1.png' width=600> </img></div>
+
+
+然后就找到了下表2，指向b，继续匹配：如图：
+<img src='../../media/pics/KMP精讲2.png' width=600> </img></div>
+
+以下这句话，对于理解为什么使用前缀表可以告诉我们匹配失败之后跳到哪里重新匹配 非常重要！
+
+**下表5之前这部分的字符串（也就是字符串aabaa）的最长相等的前缀 和 后缀字符串是 子字符串aa ，因为找到了最长相等的前缀和后缀，匹配失败的位置是后缀子串的后面，那么我们找到与其相同的前缀的后面从新匹配就可以了。**
+
+所以前缀表具有告诉我们当前位置匹配失败，跳到之前已经匹配过的地方的能力。
+
+**很多介绍KMP的文章或者视频并没有把为什么要用前缀表？这个问题说清楚，而是直接默认使用前缀表。**
+
+# 如何计算前缀表
+
+接下来就要说一说怎么计算前缀表。
+
+如图：
+
+<img src='../../media/pics/KMP精讲5.png' width=600> </img></div>
+
+长度为前1个字符的子串`a`，最长相同前后缀的长度为0。（注意字符串的**前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串**；**后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串**。）
+
+<img src='../../media/pics/KMP精讲6.png' width=600> </img></div>
+长度为前2个字符的子串`aa`，最长相同前后缀的长度为1。
+
+<img src='../../media/pics/KMP精讲7.png' width=600> </img></div>
+长度为前3个字符的子串`aab`，最长相同前后缀的长度为0。
+
+以此类推：
+长度为前4个字符的子串`aaba`，最长相同前后缀的长度为1。
+长度为前5个字符的子串`aabaa`，最长相同前后缀的长度为2。
+长度为前6个字符的子串`aabaaf`，最长相同前后缀的长度为0。
+
+那么把求得的最长相同前后缀的长度就是对应前缀表的元素，如图：
+<img src='../../media/pics/KMP精讲8.png' width=600> </img></div>
+
+可以看出模式串与前缀表对应位置的数字表示的就是：**下表i之前（包括i）的字符串中，有多大长度的相同前缀后缀。**
+
+再来看一下如何利用 前缀表找到 当字符不匹配的时候应该指针应该移动的位置。如动画所示：
+
+<img src='../../media/video/KMP精讲2.gif' width=600> </img></div>
+
+找到的不匹配的位置， 那么此时我们要看它的前一个字符的前缀表的数值是多少。
+
+为什么要前一个字符的前缀表的数值呢，因为要找前面字符串的最长相同的前缀和后缀。
+
+所以要看前一位的 前缀表的数值。
+
+前一个字符的前缀表的数值是2， 所有把下表移动到下表2的位置继续比配。 可以再反复看一下上面的动画。
+
+最后就在文本串中找到了和模式串匹配的子串了。
+
+# 前缀表与next数组
+
+很多KMP算法的时间都是使用next数组来做回退操作，那么next数组与前缀表有什么关系呢？
+
+next数组就可以是前缀表，但是很多实现都是把前缀表统一减一（右移一位，初始位置为-1）之后作为next数组。
+
+为什么这么做呢，其实也是很多文章视频没有解释清楚的地方。
+
+其实**这并不涉及到KMP的原理，而是具体实现，next数组即可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。**
+
+后面我会提供两种不同的实现代码，大家就明白了了。
+
+# 使用next数组来匹配
+
+以下我们以前缀表统一减一之后的next数组来做演示。
+
+有了next数组，就可以根据next数组来 匹配文本串s，和模式串t了。
+
+注意next数组是新前缀表（旧前缀表统一减一了）。
+
+匹配过程动画如下：
+
+<img src='../../media/video/KMP精讲4.gif' width=600> </img></div>
+
+# 时间复杂度分析
+
+
+其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。
+
+暴力的解法显而易见是O(n * m)，所以**KMP在字符串匹配中极大的提高的搜索的效率。**
+
+为了和[字符串：KMP是时候上场了（一文读懂系列）](https://mp.weixin.qq.com/s/70OXnZ4Ez29CKRrUpVJmug)字符串命名统一，方便大家理解，以下文章统称haystack为文本串, needle为模式串。

 都知道使用KMP算法，一定要构造next数组。

@ -62,7 +231,7 @@ int j = -1;
 next[0] = j;
 ```

-j 为什么要初始化为 -1呢，因为之前说过 前缀表要统一减一的操作，所以j初始化为-1。
+j 为什么要初始化为 -1呢，因为之前说过 前缀表要统一减一的操作仅仅是其中的一种实现，我们这里选择j初始化为-1，下文我还会给出j不初始化为-1的实现代码。

 next[i] 表示 i（包括i）之前最长相等的前后缀长度（其实就是j）

@ -200,7 +369,7 @@ for (int i = 0; i < s.size(); i++) { // 注意i就从0开始

 此时所有逻辑的代码都已经写出来了，本题整体代码如下：

-## C++代码
+# 前缀表统一减一 C++代码实现

 ```
 class Solution {
@ -242,7 +411,61 @@ public:

 ```

-前缀表不减一版本
+# 前缀表（不减一）C++实现
+
+那么前缀表就不减一了，也不右移的，到底行不行呢？行！
+
+我之前说过，这仅仅是KMP算法实现上的问题，如果就直接使用前缀表可以换一种回退方式，找j=next[j-1] 来进行回退。
+
+主要就是j=next[x]这一步最为关键！
+
+我给出的getNext的实现为：（前缀表统一减一）
+
+```
+void getNext(int* next, const string& s) {
+    int j = -1;
+    next[0] = j;
+    for(int i = 1; i < s.size(); i++) { // 注意i从1开始
+        while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
+            j = next[j]; // 向前回溯
+        }
+        if (s[i] == s[j + 1]) { // 找到相同的前后缀
+            j++;
+        }
+        next[i] = j; // 将j（前缀的长度）赋给next[i]
+    }
+}
+
+```
+此时如果输入的模式串为aabaaf，对应的next为-1 0 -1 0 1 -1。
+
+这里j和next[0]初始化为-1，整个next数组是以 前缀表减一之后的效果来构建的。
+
+那么前缀表不减一来构建next数组，代码如下：
+
+```
+    void getNext(int* next, const string& s) {
+        int j = 0;
+        next[0] = 0;
+        for(int i = 1; i < s.size(); i++) {
+            while (j > 0 && s[i] != s[j]) { // j要保证大于0，因为下面有取j-1作为数组下表的操作
+                j = next[j - 1]; // 注意这里，是要找前一位的对应的回退位置了
+            }
+            if (s[i] == s[j]) {
+                j++;
+            }
+            next[i] = j;
+        }
+    }
+
+```
+
+此时如果输入的模式串为aabaaf，对应的next为 0 1 0 1 2 0，（其实这就是前缀表的数值了）。
+
+那么用这样的next数组也可以用来做匹配，代码要有所改动。
+
+实现代码如下：
+
 ```
 class Solution {
 public:
@ -281,5 +504,21 @@ public:
    }
 };
 ```
+
+# 总结
+
+我们介绍了什么是KMP，KMP可以解决什么问题，然后分析KMP算法里的next数组，知道了next数组就是前缀表，再分析为什么要是前缀表而不是什么其他表。
+
+接着从给出的模式串中，我们一步一步的推导出了前缀表，得出前缀表无论是统一减一还是不同意减一得到的next数组仅仅是kmp的实现方式的不同。
+
+其中还分析了KMP算法的时间复杂度，并且和暴力方法做了对比。
+
+然后先用前缀表统一减一得到的next数组，求得文本串s里是否出现过模式串t，并给出了具体分析代码。
+
+又给出了直接用前缀表作为next数组，来做匹配的实现代码。
+
+可以说把KMP的每一个细微的细节都扣了出来，毫无遮掩的展示给大家了！
+
+
 > 更多算法干货文章持续更新，可以微信搜索「代码随想录」第一时间围观，关注后，回复「Java」「C++」 「python」「简历模板」「数据结构与算法」等等，就可以获得我多年整理的学习资料。

--- a/problems/0040.组合总和II.md
+++ b/problems/0040.组合总和II.md
@ -30,43 +30,68 @@ candidates 中的每个数字在每个组合中只能使用一次。

 # 思想 

+这道题目和[0039.组合总和](https://github.com/youngyangyang04/leetcode/blob/master/problems/0039.组合总和.md) 区别就是要去重。
+
+很多同学在去重上想不明白，其实很多题解也没有讲清楚，反正代码是能过的，感觉是那么回事，稀里糊涂的先把题目过了。
+
+这个去重为什么很难理解呢，**所谓去重，其实就是使用过的元素不能重复选取。** 这么一说好像很简单！
+
+
+都知道组合问题可以抽象为树形结构，那么“使用过”在这个树形结构上是有两个维度的，一个维度是同一树枝上使用过，一个维度是同一树层上使用过。**没有理解这两个层面上的“使用过” 是造成大家没有彻底理解去重的根本原因。**
+
+所以要明确我们要去重的是同一树层上的“使用过”。
+
+为了理解去重我们来举一个例子，candidates = [1, 1, 2], target = 3，（方便起见candidates已经排序了）
+
+选择过程如图所示：
+
+<img src='../pics/40.组合总和II.png' width=600> </img></div>
+
+
+理解了“同一树枝使用过”和“同一树层使用过” 之后，我们在拉看如下代码实现，关键地方已经注释，大家应该就理解了
+
 # C++代码 

 ```
 class Solution {
 private:
    vector<vector<int>> result;
-    void backtracking(vector<int>& candidates, int target, vector<int>& vec, int sum, int startIndex, vector<bool>& used) {
+    vector<int> path;
+    void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {
        if (sum > target) {
            return;
        }
        if (sum == target) {
-            result.push_back(vec);
+            result.push_back(path);
            return;
        }

-// 每个组合中只能使用一次 所以用 startindex
-// 给定一个数组 candidates 默认有重复项，解集不能包含重复的组合。  所以使用if这一套
+        // 每个组合中只能使用一次 所以用 startindex
+        // 给定一个数组 candidates 默认有重复项，解集不能包含重复的组合。  所以使用if这一套
        for (int i = startIndex; i < candidates.size(); i++) {
-            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
+            // 这里理解used[i - 1]非常重要 
+            // used[i - 1] == true，说明同一树支candidates[i - 1]使用过 
+            // used[i - 1] == false，说明同一树层candidates[i - 1]使用过
+            // 而我们要对同一树层使用过的元素进行跳过
+            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) { 
                continue;
            }
            sum += candidates[i];
-            vec.push_back(candidates[i]);
+            path.push_back(candidates[i]);
            used[i] = true;
-            backtracking(candidates, target, vec, sum, i + 1, used); // 关键点在这里，不用i+1了
+            backtracking(candidates, target, sum, i + 1, used); // 关键点在这里，不用i+1了
            used[i] = false;
            sum -= candidates[i];
-            vec.pop_back();
+            path.pop_back();
        }
    }

 public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
-        vector<int> vec;
        vector<bool> used(candidates.size(), false);
+        // 首先把给candidates排序，让其相同的元素都挨在一起。 
        sort(candidates.begin(), candidates.end());
-        backtracking(candidates, target, vec, 0, 0, used);
+        backtracking(candidates, target, 0, 0, used);
        return result;

    }
--- a/problems/0459.重复的子字符串.md
+++ b/problems/0459.重复的子字符串.md
@ -84,7 +84,7 @@ public:
 };
 ```

-# next减一C++代码 
+# 前缀表不右移 C++代码 

 ```
 class Solution {
--- a/problems/字符串总结.md
+++ b/problems/字符串总结.md
@ -1,5 +1,10 @@
-# 字符串：帮你对字符串不再恐惧（总结篇）
+> 该做一个总结了

+# 字符串：总结篇
+
+其实我们已经学习了十天的字符串了，从字符串的定义到库函数的使用原则，从各种反转到KMP算法，相信大家应该对字符串有比较深刻的认识了。 
+
+那么这次我们来做一个总结。

 # 什么是字符串

@ -35,23 +40,26 @@ for (int i = 0; i < a.size(); i++) {

 在文章[字符串：这道题目，使用库函数一行代码搞定](https://mp.weixin.qq.com/s/X02S61WCYiCEhaik6VUpFA)中强调了**打基础的时候，不要太迷恋于库函数。**

-甚至一些同学习惯于调用substr，split，reverse之类的库函数，却不知道其实现原理，也不知道其时间复杂度，这样实现出来的代码，如果在面试面试现场，面试官问：“分析其时间复杂度”的话，一定会一脸懵逼！
+甚至一些同学习惯于调用substr，split，reverse之类的库函数，却不知道其实现原理，也不知道其时间复杂度，这样实现出来的代码，如果在面试现场，面试官问：“分析其时间复杂度”的话，一定会一脸懵逼！

-所以我们建议**如果题目关键的部分直接用库函数就可以解决，建议不要使用库函数。**
+所以建议**如果题目关键的部分直接用库函数就可以解决，建议不要使用库函数。**

 **如果库函数仅仅是 解题过程中的一小部分，并且你已经很清楚这个库函数的内部实现原理的话，可以考虑使用库函数。**

 # 双指针法


-在[字符串：这道题目，使用库函数一行代码搞定](https://mp.weixin.qq.com/s/X02S61WCYiCEhaik6VUpFA) ，我们使用双指针法实现了反转字符串的操作，双指针法在数组，链表和字符串中很常用。
-
-双指针法在数组，链表，字符串操作中，经常会使用双指针法。
+在[字符串：这道题目，使用库函数一行代码搞定](https://mp.weixin.qq.com/s/X02S61WCYiCEhaik6VUpFA) ，我们使用双指针法实现了反转字符串的操作，**双指针法在数组，链表和字符串中很常用。**

 接着在[字符串：替换空格](https://mp.weixin.qq.com/s/t0A9C44zgM-RysAQV3GZpg)，同样还是使用双指针法在时间复杂度O(n)的情况下完成替换空格。

 **其实很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。**

+那么针对数组删除操作的问题，其实在[数组：就移除个元素很难么？](https://mp.weixin.qq.com/s/wj0T-Xs88_FHJFwayElQlA)中就已经提到了使用双指针法进行移除操作。
+
+同样的道理在[字符串：花式反转还不够！](https://mp.weixin.qq.com/s/X3qpi2v5RSp08mO-W5Vicw)中我们使用O(n)的时间复杂度，完成了删除冗余空格。
+
+一些同学会使用for循环里调用库函数erase来移除元素，这其实是O(n^2)的操作，因为erase就是O(n)的操作，所以这也是典型的不知道库函数的时间复杂度，上来就用的案例了。

 # 反转系列

@ -75,21 +83,34 @@ for (int i = 0; i < a.size(); i++) {

 # KMP 

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

-首先要理解KMP的理论基础，[字符串：KMP是时候上场了（一文读懂系列）](https://mp.weixin.qq.com/s/70OXnZ4Ez29CKRrUpVJmug)，这里提到了，什么是KMP，什么是前缀表，以及为什么要用前缀表
+KMP的精髓所在就是前缀表，在[字符串：KMP是时候上场了（一文读懂系列）](https://mp.weixin.qq.com/s/70OXnZ4Ez29CKRrUpVJmug)中提到了，什么是KMP，什么是前缀表，以及为什么要用前缀表。

+前缀表：起始位置到下表i之前（包括i）的子串中，有多大长度的相同前缀后缀。

+那么使用KMP可以解决两类经典问题：

-打基础的时候，不要太迷恋于库函数
+1. 匹配问题：[28. 实现 strStr()](https://mp.weixin.qq.com/s/Gk9FKZ9_FSWLEkdGrkecyg)
+2. 重复子串问题：[459.重复的子字符串](https://mp.weixin.qq.com/s/lR2JPtsQSR2I_9yHbBmBuQ)

-* [字符串：反转个字符串还有这个用处？](https://mp.weixin.qq.com/s/PmcdiWSmmccHAONzU0ScgQ)
+在[字符串：听说你对KMP有这些疑问？](https://mp.weixin.qq.com/s/mqx6IM2AO4kLZwvXdPtEeQ) 强调了什么是前缀，什么是后缀，什么又是最长相等前后缀。
+
+前缀：指不包含最后一个字符的所有以第一个字符开头的连续子串。
+
+后缀：指不包含第一个字符的所有以最后一个字符结尾的连续子串。
+
+然后**针对前缀表到底要不要减一，这其实是不同KMP实现的方式**，我们在[字符串：前缀表不右移，难道就写不出KMP了？](https://mp.weixin.qq.com/s/p3hXynQM2RRROK5c6X7xfw)中针对之前两个问题，分别给出了两个不同版本的的KMP实现。
+
+其中主要**理解j=next[x]这一步最为关键！**
+
+# 总结 
+
+字符串类类型的题目，往往想法比较简单，但是实现起来并不容易，复杂的字符串题目非常考验对代码的掌控能力。
+
+双指针法是字符串处理的常客。
+
+KMP算法是字符串查找最重要的算法，但彻底理解KMP并不容易，我们已经写了五篇KMP的文章，不断总结和完善，最终才把KMP讲清楚。
+
+好了字符串相关的算法知识就介绍到了这里了，明天开始新的征程，大家加油！

-* [字符串：这道题目，使用库函数一行代码搞定](https://mp.weixin.qq.com/s/X02S61WCYiCEhaik6VUpFA)
-* [字符串：简单的反转还不够！](https://mp.weixin.qq.com/s/XGSk1GyPWhfqj2g7Cb1Vgw)
-* [字符串：替换空格](https://mp.weixin.qq.com/s/t0A9C44zgM-RysAQV3GZpg)
-* [字符串：花式反转还不够！](https://mp.weixin.qq.com/s/X3qpi2v5RSp08mO-W5Vicw)
-* [字符串：KMP是时候上场了（一文读懂系列）](https://mp.weixin.qq.com/s/70OXnZ4Ez29CKRrUpVJmug)
-* [字符串：都来看看KMP的看家本领！](https://mp.weixin.qq.com/s/Gk9FKZ9_FSWLEkdGrkecyg)
-* [字符串：听说你对KMP有这些疑问？](https://mp.weixin.qq.com/s/mqx6IM2AO4kLZwvXdPtEeQ)
-* [字符串：KMP算法还能干这个！](https://mp.weixin.qq.com/s/lR2JPtsQSR2I_9yHbBmBuQ)