DAY8 字符串2

知识点：KMP

1.什么是KMP

说到KMP，先说一下KMP这个名字是怎么来的，为什么叫做KMP呢。

因为是由这三位学者发明的：Knuth，Morris和Pratt，所以取了三位学者名字的首字母。所以叫做KMP。

2.KMP有什么用

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

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

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

3.什么是前缀表

写过KMP的同学，一定都写过next数组，那么这个next数组究竟是个啥呢？

next数组就是一个前缀表（prefix table）。

前缀表有什么作用呢？

前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。（不要深究这句话，往后看就明白了）

为了清楚地了解前缀表的来历，我们来举一个例子：

要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。

请记住文本串和模式串的作用，对于理解下文很重要，要不然容易看懵。

如动画所示：

动画里，我特意把 子串aa 标记上了，这是有原因的，大家先注意一下，后面还会说到。

可以看出，文本串中第六个字符b 和 模式串的第六个字符f，不匹配了。如果暴力匹配，发现不匹配，此时就要从头匹配了；但如果使用前缀表，就不会从头匹配，而是从上次已经匹配的内容开始匹配，找到了模式串中第三个字符b继续开始匹配。

此时就要问了前缀表是如何记录的呢？

首先要知道前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，再重新匹配，此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。

那么什么是前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

4.最长公共前后缀？

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

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

正确理解什么是前缀什么是后缀很重要!

那么网上清一色都说 “kmp 最长公共前后缀” 又是什么回事呢？

我查了一遍 算法导论 和 算法4里KMP的章节，都没有提到 “最长公共前后缀”这个词，也不知道从哪里来了，我理解是用“最长相等前后缀” 更准确一些。因为前缀表要求的就是相同前后缀的长度。

所以字符串a的最长相等前后缀为0。 字符串aa的最长相等前后缀为1。 字符串aaa的最长相等前后缀为2

5.前缀表怎么告诉我们上次匹配的位置？

这就是前缀表，那为啥就能告诉我们 上次匹配的位置，并跳过去呢？

回顾一下，刚刚匹配的过程在下标5的地方遇到不匹配，模式串是指向f，如图：

 

然后就找到了下标2，指向b，继续匹配：如图：

 

以下这句话，对于理解为什么使用前缀表可以告诉我们匹配失败之后跳到哪里重新匹配 非常重要！

下标5之前这部分的字符串（也就是字符串aabaa）的最长相等的前缀 和 后缀字符串是 子字符串aa ，因为找到了最长相等的前缀和后缀，匹配失败的位置是后缀子串的后面，那么我们找到与其相同的前缀的后面重新匹配就可以了。

所以前缀表具有告诉我们当前位置匹配失败，跳到之前已经匹配过的地方的能力。

很多介绍KMP的文章或者视频并没有把为什么要用前缀表？这个问题说清楚，而是直接默认使用前缀表。（我第一次学KMP的时候也是在网上找了好久，几乎没有人说这个前缀表的事情，只有卡子哥说了，这个也是我后面能理解KMP的关键）

6.如何计算前缀表

如图：

 

长度为前1个字符的子串a，最长相同前后缀的长度为0。（注意字符串的前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串；后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。）

长度为前2个字符的子串aa，最长相同前后缀的长度为1。

长度为前3个字符的子串aab，最长相同前后缀的长度为0。

以此类推： 长度为前4个字符的子串aaba，最长相同前后缀的长度为1。 长度为前5个字符的子串aabaa，最长相同前后缀的长度为2。 长度为前6个字符的子串aabaaf，最长相同前后缀的长度为0。

那么把求得的最长相同前后缀的长度就是对应前缀表的元素，如图：

 

可以看出模式串与前缀表对应位置的数字表示的就是：下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

再来看一下如何利用 前缀表找到 当字符不匹配的时候应该指针应该移动的位置。如动画所示：

 

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

为什么要前一个字符的前缀表的数值呢，因为要找前面字符串的最长相同的前缀和后缀。

所以要看前一位的 前缀表的数值。

前一个字符的前缀表的数值是2， 所以把下标移动到下标2的位置继续比配。 可以再反复看一下上面的动画。

最后就在文本串中找到了和模式串匹配的子串了。

7.前缀表与next数组

很多KMP算法的时间都是使用next数组来做回退操作，那么next数组与前缀表有什么关系呢？

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

为什么这么做呢，其实也是很多文章视频没有解释清楚的地方。

其实这并不涉及到KMP的原理，而是具体实现，next数组既可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。

后面我会提供两种不同的实现代码，大家就明白了。

8.使用next数组来匹配

以下我们以前缀表统一减一之后的next数组来做演示。

有了next数组，就可以根据next数组来 匹配文本串s，和模式串t了。

注意next数组是新前缀表（旧前缀表统一减一了）。

匹配过程动画如下：

 

9.时间复杂度分析

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

暴力的解法显而易见是O(n × m)，所以KMP在字符串匹配中极大地提高了搜索的效率。

为了和力扣题目28.实现strStr保持一致，方便大家理解，以下文章统称haystack为文本串, needle为模式串。

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

10.构造next数组（难）（核心）

我们定义一个函数getNext来构建next数组，函数参数为指向next数组的指针，和一个字符串。 代码如下：

 void getNext(int* next, const string& s)

构造next数组其实就是计算模式串s，前缀表的过程。 主要有如下三步：

1. 初始化

2. 处理前后缀不相同的情况

3. 处理前后缀相同的情况

接下来我们详解一下。

1.初始化：

定义两个指针i和j，(j+1)指向前缀末尾位置（同时代表在一轮for循环结束时字符串子序列的最长相同前后缀的长度），i指向后缀末尾位置。

然后还要对next数组进行初始化赋值，如下：

理解：初始化的时候其实就是把字符串中第一个字符的回退位置给求出来了。所以后面for (int i = 1; i < s.size(); i++)开始的时候，是以字符串的前两个字符为子串求出其前缀和。

 int j = -1;
 next[0] = j;

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

next[i] 表示 i（包括i）之前最长相等的前后缀长度（其实就是j）——》所以初始化next[0] = j 。

2.处理前后缀不相同的情况

（1）i的初始化

因为j初始化为-1，即(j+1)为0，那么i就从1开始，进行s[i] 与 s[j+1]的比较。

（2）遍历

所以遍历模式串s的循环下标i 要从 1开始，代码如下：

 for (int i = 1; i < s.size(); i++) {//i初始化为1后，i和j才能比较

如果 s[i] 与 s[j+1]不相同，也就是遇到 前后缀末尾不相同的情况，就要向前回退。

（3）回退

怎么回退呢？

next[j]就是记录着j（包括j）之前的子串的相同前后缀的长度。

那么 s[i] 与 s[j+1] 不相同，就要找 j+1前一个元素在next数组里的值（就是next[j]）。

所以，处理前后缀不相同的情况代码如下：

 while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了;j>=0是为了防止下面的next数组越界访问
     j = next[j]; // 向前回退，回退的位数要看(j+1)的前一位
 }

3.处理前后缀相同的情况

如果 s[i] 与 s[j + 1] 相同，那么就同时向后移动i 和j 说明找到了相同的前后缀，同时还要将j（前缀的长度）赋给next[i], 因为next[i]要记录相同前后缀的长度。

代码如下：

 if (s[i] == s[j + 1]) { // 找到相同的前后缀
     j++;
 }
 next[i] = j;//j不仅代表每个字符串子序列的后缀末尾，还代表一个字符串子序列的最长相同前后缀的长度。

4.整体代码

最后整体构建next数组的函数代码如下：

 void getNext(int* next, const string& s){
     /*1.初始化*/
     int j = -1;
     next[0] = j;
     /*2.循环处理*/
     for(int i = 1; i < s.size(); i++) { // 注意i从1开始
         //j不满足大于等于0的条件的时候，也就是还在进行第一次的字符串匹配，这时next数组中就只有next[0]有初始的无用值，所以也没有回退这个操作。
     /*3.前后缀不相同*/
         while (j >= 0 && s[i] != s[j + 1]) // 注意这里是while而不是if，回退的时候是会出现连续回退的情况的——》如下面的动图例子：s[i]=f时，(j+1)指针会先回退到(next[4]+1)对应的下标处，也就是(j+1)回退到下标2的位置；然后s[2]=b!=s[5]=f,所以指针i又要回退到(next[2]+1)对应的下标位置。
         { 
             j = next[j]; // 向前回退--》因为next[0]=-1,所以如果一直回退的话，最终会以j=-1而终止while循环。
         }
     /*4.找到相同的前后缀*/
         if (s[i] == s[j + 1]) { 
             j++;//j也不会在每一次for循环结束后清空，这是计算aabaa这个子串的最长前后缀最妙的地方；在计算aaba的最长字串结束时，i=1；而下一次for循环时，i又++变为2了，符合aabaa的最长字串的结果。
         }
     /*5.构建next[]数组*/
         next[i] = j; // 将j赋给next[i]（j的含义是前缀末尾，在一轮i为特定值的for循环内部代码执行结束时，j该回退或者该++的操作都已经做完了，这是j最后的位置就是目前这次for循环所处理的字符串子序列的最长相同前后缀的长度）
     }
 }

得到了next数组之后，就要用这个来做匹配了。

11.使用next数组来做匹配

文本串s里 找是否出现过模式串t。

（1）下标初始化

定义两个下标：j 指向模式串起始位置，i指向文本串起始位置。

那么j初始值依然为-1，为什么呢？ 依然因为next数组里记录的起始位置为-1。

（2）遍历文本串

i就从0开始，遍历文本串，代码如下：

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

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

（2.1）如果 s[i] 与 t[j + 1] 不相同，j就要从next数组里寻找下一个匹配的位置。

代码如下：

 while(j >= 0 && s[i] != t[j + 1]) {//j=-1的时候也就是将模式串中的第一个字符与文本串字符进行匹配，当他们不相同的时候，模式串的指针也已经不能再往前了，要不就越界了，这已经是模式串的第一个字符了！！所以while循环需要j>=0这个条件。
     j = next[j];
 }

（2.2）如果 s[i] 与 t[j + 1] 相同，那么i 和 j 同时向后移动， 代码如下：

 if (s[i] == t[j + 1]) {
     j++; // i的增加在for循环里
 }

（2.3）如何判断在文本串s里出现了模式串t呢，如果j指向了模式串t的末尾，那么就说明模式串t完全匹配文本串s里的某个子串了。

本题要在文本串字符串中找出模式串出现的第一个位置 (从0开始)，所以返回当前在文本串匹配模式串的位置i 减去 模式串的长度，就是文本串字符串中出现模式串的第一个位置。

代码如下：

 if (j == (t.size() - 1) ) {
     return (i - t.size() + 1);
 }

那么使用next数组，用模式串匹配文本串的整体代码如下：

 //注意区分生成前缀表时的指针i、j和进行模式串和文本串匹配时的指针i和j
 int j = -1; // 因为next数组里记录的起始位置为-1
 for (int i = 0; i < s.size(); i++) { // 注意i就从0开始
     while(j >= 0 && s[i] != t[j + 1]) { // 文本串当前字符与模式串当前字符不匹配
         j = next[j]; // 使用next数组寻找要返回到的位置
     }
     if (s[i] == t[j + 1]) { // 匹配，j和i同时向后移动
         j++; // i的增加在for循环里
     }
     if (j == (t.size() - 1) ) 
     { // 文本串s里出现了模式串t
         return (i - t.size() + 1);
     }
 }

此时所有逻辑的代码都已经写出来了

力扣 28.实现strStr 题目的整体代码见后面。

一、28. 找出字符串中第一个匹配项的下标

题目连接：力扣

1.前缀表统一减一 C++代码实现

 class Solution {
 public:
     //1.生成前缀表next[]——》注意区分生成前缀表时的指针i、j和进行模式串和文本串匹配时的指针i和j
     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]
         }
     }
     //2.进行模式串和文本串匹配
     int strStr(string haystack, string needle) 
     {
         if (needle.size() == 0) 
         {
             return 0;
         }
         int next[needle.size()];
         getNext(next, needle);//生成next数组
         int j = -1; // // 因为next数组里记录的起始位置为-1
         for (int i = 0; i < haystack.size(); i++) 
         { // 注意i就从0开始
             while(j >= 0 && haystack[i] != needle[j + 1]) // 不匹配
             { 
                 j = next[j]; // 通过next数组，j寻找之前匹配的位置（回退位置）
             }
             if (haystack[i] == needle[j + 1]) 
             { // 匹配，j和i同时向后移动
                 j++; // i的增加在for循环里
             }
             if (j == (needle.size() - 1) ) 
             { // 文本串s里出现了模式串t
                 return (i - needle.size() + 1);
             }
         }
         return -1;
     }
 };

2.前缀表（不减一）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:
     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 = next[j - 1];
             }
             if (s[i] == s[j]) {
                 j++;
             }
             next[i] = j;
         }
     }
     int strStr(string haystack, string needle) {
         if (needle.size() == 0) {
             return 0;
         }
         int next[needle.size()];
         getNext(next, needle);
         int j = 0;
         for (int i = 0; i < haystack.size(); i++) {
             while(j > 0 && haystack[i] != needle[j]) {
                 j = next[j - 1];
             }
             if (haystack[i] == needle[j]) {
                 j++;
             }
             if (j == needle.size() ) {
                 return (i - needle.size() + 1);
             }
         }
         return -1;
     }
 };

• 时间复杂度: O(n + m)

• 空间复杂度: O(m)

二、459.重复的子字符串

题目链接：力扣

 给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
 示例 1:
 输入: "abab"
 输出: True
 解释: 可由子字符串 "ab" 重复两次构成。
 示例 2:
 输入: "aba"
 输出: False
 示例 3:
 输入: "abcabcabcabc"
 输出: True
 解释: 可由子字符串 "abc" 重复四次构成。 (或者子字符串 "abcabc" 重复两次构成。)

我的思路：上一道题目里面是只要在文本串里面找到一个和模式串相同的子串，就return了，很显然这题里面不能这么做。——》我觉得每次找到后应该记录每次匹配的子串的首字符在文本串中的下标，最后看这些下标是不是连续的。

卡子哥思路：2种

1.移动匹配

当一个字符串s：abcabc，内部由重复的子串组成，那么这个字符串的结构一定是这样的：

也就是由前后相同的子串组成。

那么既然前面有相同的子串，后面有相同的子串，用 s + s，这样组成的字符串中，后面的子串做前串，前后的子串做后串，就一定还能组成一个s，如图：

所以判断字符串s是否由重复子串组成，只要两个s拼接在一起，里面还出现一个s的话，就说明是由重复子串组成。

当然，我们在判断 s + s 拼接的字符串里是否出现一个s的的时候，要刨除 s + s 的首字符和尾字符，这样避免在s+s中搜索出原来的s，我们要搜索的是中间拼接出来的s（重要）。

代码如下：

 class Solution {
 public:
     bool repeatedSubstringPattern(string s) {
         string t = s + s;
         t.erase(t.begin()); t.erase(t.end() - 1); // 掐头去尾
         if (t.find(s) != std::string::npos) return true; // r
         return false;
     }
 };

• 时间复杂度: O(n)

• 空间复杂度: O(1)

不过这种解法还有一个问题，就是 我们最终还是要判断 一个字符串（s + s）是否出现过 s 的过程，大家可能直接用contains，find 之类的库函数。 却忽略了实现这些函数的时间复杂度（暴力解法是m * n，一般库函数实现为 O(m + n)）。

如果我们做过 “28.实现strStr”题目的话，其实就知道，实现一个 高效的算法来判断 一个字符串中是否出现另一个字符串是很复杂的，这里就涉及到了KMP算法。

2.KMP

（1）为什么会使用KMP

在一个串中查找是否出现过另一个串，这是KMP的看家本领。那么寻找重复子串怎么也涉及到KMP算法了呢？——KMP算法中next数组为什么遇到字符不匹配的时候可以找到上一个匹配过的位置继续匹配，靠的是有计算好的前缀表。 前缀表里，统计了各个位置为终点字符串的最长相同前后缀的长度。

那么 最长相同前后缀 和 重复子串又有什么关系呢？

可能很多录友又忘了 前缀和后缀的定义，再回顾一下：

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

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

在由重复子串组成的字符串中，最长相等前后缀不包含的子串就是最小重复子串，这里拿字符串s：abababab 来举例，ab就是最小重复单位，如图所示：

（2）如何找到最小重复子串

这里有同学就问了，为啥一定是开头的ab呢。 其实最关键还是要理解 最长相等前后缀，如图：

步骤一：因为 这是相等的前缀和后缀，t[0] 与 k[0]相同， t[1] 与 k[1]相同，所以 s[0] 一定和 s[2]相同，s[1] 一定和 s[3]相同，即：，s[0]s[1]与s[2]s[3]相同 。

步骤二： 因为在同一个字符串位置，所以 t[2] 与 k[0]相同，t[3] 与 k[1]相同。

步骤三： 因为 这是相等的前缀和后缀，t[2] 与 k[2]相同 ，t[3]与k[3] 相同，所以，s[2]一定和s[4]相同，s[3]一定和s[5]相同，即：s[2]s[3] 与 s[4]s[5]相同。

步骤四：循环往复。

所以字符串s，s[0]s[1]与s[2]s[3]相同， s[2]s[3] 与 s[4]s[5]相同，s[4]s[5] 与 s[6]s[7] 相同。

正是因为 最长相等前后缀的规则，当一个字符串由重复子串组成的，最长相等前后缀不包含的子串就是最小重复子串。

（3）简单推简单推理

这里再给出一个数学推导，就容易理解很多。

假设字符串s使用多个重复子串构成（这个子串是最小重复单位），重复出现的子字符串长度是x，所以s是由n * x组成。

因为字符串s的最长相同前后缀的长度一定是不包含s本身，所以 最长相同前后缀长度必然是m * x，而且 n - m = 1，（这里如果不懂，看上面的推理）

所以如果 nx % (n - m)x = 0，就可以判定有重复出现的子字符串。

next 数组记录的就是最长相同前后缀 ， 如果 next[len - 1]不等于 -1，则说明字符串有最长相同的前后缀。

最长相等前后缀的长度为：next[len - 1] + 1(这里的next数组是以统一减一的方式计算的，因此需要+1）

数组长度为：len。

如果len % (len - (next[len - 1] + 1)) == 0 ，则说明数组的长度正好可以被 (数组长度-最长相等前后缀的长度) 整除 ，说明该字符串有重复的子字符串。

数组长度减去最长相同前后缀的长度相当于是第一个周期的长度，也就是一个周期的长度，如果这个周期可以被整除，就说明整个数组就是这个周期的循环。

强烈建议大家把next数组打印出来，看看next数组里的规律，有助于理解KMP算法

如图：

 

next[len - 1] = 7，next[len - 1] + 1 = 8，8就是此时字符串asdfasdfasdf的最长相同前后缀的长度。

(len - (next[len - 1] + 1)) 也就是： 12(字符串的长度) - 8(最长公共前后缀的长度) = 4， 4正好可以被 12(字符串的长度) 整除，所以说明有重复的子字符串（asdf）。

C++代码如下：（这里使用了前缀表统一减一的实现方式）

 class Solution {
 public:
     //1.创建next数组
     void getNext (int* next, const string& s){
         next[0] = -1;
         int j = -1;
         for(int i = 1;i < s.size(); i++){
             while(j >= 0 && s[i] != s[j + 1]) {
                 j = next[j];
             }
             if(s[i] == s[j + 1]) {
                 j++;
             }
             next[i] = j;
         }
     }
     bool repeatedSubstringPattern (string s) {
         if (s.size() == 0) {
             return false;
         }
         int next[s.size()];
         getNext(next, s);
         int len = s.size();
         if (next[len - 1] != -1 && len % (len - (next[len - 1] + 1)) == 0) {
             return true;
         }
         return false;
     }
 };

• 时间复杂度: O(n)

• 空间复杂度: O(n)

前缀表（不减一）的C++代码实现：

 class Solution {
 public:
     void getNext (int* next, const string& s){
         next[0] = 0;
         int j = 0;
         for(int i = 1;i < s.size(); i++){
             while(j > 0 && s[i] != s[j]) {
                 j = next[j - 1];
             }
             if(s[i] == s[j]) {
                 j++;
             }
             next[i] = j;
         }
     }
     bool repeatedSubstringPattern (string s) {
         if (s.size() == 0) {
             return false;
         }
         int next[s.size()];
         getNext(next, s);
         int len = s.size();
         if (next[len - 1] != 0 && len % (len - (next[len - 1] )) == 0) {
             return true;
         }
         return false;
     }
 };

• 时间复杂度: O(n)

• 空间复杂度: O(n)