DAY9 实现strSTR（）&& 重复子字符串

6.实现strStr（）

strstr()：在一个字符串中搜索指定的子字符串。\#include <memory.h>

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

示例 1：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

示例 2：

输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。

提示：

• 1 <= haystack.length, needle.length <= 104
• haystack 和 needle 仅由小写英文字符组成

说明: 当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。 对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

思路

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

什么是KMP

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

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

KMP有什么用

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

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

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

什么是前缀表

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

前缀表有什么作用呢？前缀表里，统计了各个位置为终点字符串的最长相同前后缀的长度。

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

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

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

这里的模式串前缀有:

a
aa
aab
aabaa

后缀有：

f
af
aaf
baaf
abaaf

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

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

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

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

如动画所示：

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

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

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

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

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

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

最长公共前后缀

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

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

最长相等前后缀：因为前缀表要求的就是相同前后缀的长度。

而最长公共前后缀里面的“公共”，更像是说前缀和后缀公共的长度。这其实并不是前缀表所需要的。

所以字符串a的最长相等前后缀为0【因为没有前缀，也没有后缀，前缀不包含首字母，后缀不包含尾字母】 。

字符串aa的最长相等前后缀为1【因为前缀是a，后缀是a 】。 字符串aaa的最长相等前后缀为2。 等等…

模式串:aabaaf 的最长相等前后缀
a      0
aa     1
aaba   1
aabaa  2
aabaaf 0

为什么一定要用前缀表

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

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

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

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

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

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

如何计算前缀表

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

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

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

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

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

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

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

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

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

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

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

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

前缀表与next数组

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

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

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

使用next数组来匹配

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

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

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

匹配过程动画如下：

构造next数组

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

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

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

1. 初始化

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

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

4. 初始化：

定义两个指针 i 和 j ，i 指向后缀末尾位置，j 指向前缀末尾位置。同时，j = 包含 i 之前的元素的最长相等前后缀大小。

（1）首先，前缀末尾从模式串中首个位置开始，所以初始化 j = 0。那么回退的时候也是回退0的位置，所以next[ 0 ] = 0;

（2）对于 i 的初始化，后缀不包含首个字母，所以后缀只能从 模式串中 1 对应的位置开始，这样就能比较 前缀和后缀对应的字符是否相等。

就有 for( int i = 1;i < s.size(); i ++)遍历模式串。

2. while（j > 0 && s[ i ] != s[ j ]）, 前后缀不相同：看前一位的前缀表的值是多少，然后回退到前后追相同的位置。 j = next[ j - 1 ]

3. if (s[ i ] == s[ j ] ) j++; next[ i ] = j;前后缀相同： 开始给next数组进行赋值，更新 i 与 j；

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

#include<string>
#include<iostream>

using namespace std;

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 needSize = needle.size();
        int *next = new int[needle.size()];//因为在声明数组时，数组的大小必须是一个常量表达式，而不能是变量或函数的返回值
        //使用 new 运算符在堆上动态分配数组的内存空间
        getNext(next, needle);

        for (int i = 0,j = 0; i < haystack.size(); i++)//i是文本串的指针
        {
            while (j > 0 && haystack[i] != needle[j])//j 是模式串的指针
            {
                j = next[j - 1];
            }
            if (haystack[i] == needle[j]) {
                j++;
            }
            if (needle[j] == NULL)
            {
                return i - needSize + 1;
            }
        }
        return -1;
    }

};

7.重复子字符串

给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

示例 1:

输入: s = "abab"
输出: true
解释: 可由子串 "ab" 重复两次构成。

示例 2:

输入: s = "aba"
输出: false

示例 3:

输入: s = "abcabcabcabc"
输出: true
解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)

提示：

• 1 <= s.length <= 104
• s 由小写英文字母组成

暴力解法

以第一个字母为开始的子串就可以；

遍历的时候 都不用遍历结束，只需要遍历到中间位置，因为子串结束位置大于中间位置的话，一定不能重复组成字符串。

1.就是一个for循环获取 子串的终止位置；通过字符串长度是否能整除字串长度来判断终止位置；

2.终止位置确定后，即子串确定，通过string sub = s.substr(0, len);确定子串，累计循环次数，相加子串；是否与原字串相等。

#include<iostream>
#include<string>
using namespace std;
class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        int n = s.size();
        //len = 1;如： “bb”
        for (int len = 1; len <= n / 2; len++)//中间索引的地方也能取到，如：abab
        {
            if (n % len == 0)//能被整除
            {
                string sub = s.substr(0, len);
                cout << "sub = " << sub << endl;
                int repeat = n / len;//循环次数
                string str = "";//循环相加
                for (int i = 0; i < repeat; i++)
                {
                    str += sub;
                }
                if (str == s)//判断是否相同
                {
                    return true;
                }
            }
        }
        return false;
    }
};

移动匹配

当一个字符串s：abcabc，内部由重复的子串组成。也就是由前后相同的子串“abc”组成。

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

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

【当然，我们在判断 s + s 拼接的新字符串里是否出现一个原串s的时候，要刨除 前串s + 后串s 的首字符和尾字符，这样避免在s+s中搜索出原来的前串s，我们要搜索的是中间拼接出来的s】。即新的字串为：a ‘bcabcabcab’ c ;

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        //移动匹配
        string t = s + s;
        t.erase(t.begin());
        t.erase(t.end() - 1);//end() 返回指向字符串 t 结尾后一个位置的迭代器，而不是最后一个字符的迭代器。t.end() - 1 返回指向字符串 t 最后一个字符的迭代器
        if (t.find(s) != std::string::npos)//用于在一个字符串 t 中查找子串 s 的第一次出现的位置。该函数返回一个整数值，表示子串 s 在字符串 t 中的起始位置
        {
            cout << "t = "  << t << "  " << t.find(s) << endl;
            return true;
        }
        return false;
    }
};

1.如果 t 是字符串 “Hello”，那么 t.erase(t.end() - 1) 将删除最后一个字符 ‘o’，使得字符串变为 “Hell”。end() 返回指向字符串 t 结尾后一个位置的迭代器，而不是最后一个字符的迭代器。t.end() - 1 返回指向字符串 t 最后一个字符的迭代器.

2.t.find(s):用于在一个字符串 t 中查找子串 s 的第一次出现的位置。该函数返回一个整数值，表示子串 s 在字符串 t 中的起始位置。std::string::npos 的值是一个足够大的无符号整数，通常被定义为 std::string::size_type 类型的最大值。用于表示字符串操作中的无效位置或无法找到某个子串的特殊值。

KMP

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

在由重复子串组成的字符串中，最长相等前后缀不包含的子串就是最小重复子串，这里拿字符串s：abababab 来举例，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] 相同。

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

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

最长相同前后缀长度是m * x，而且 n - m = 1，即 最长相同前后缀 + 最小重复单元 = 字符串s；m * x + x = n * x

如果 n * x % (n - m)x = 0，就可以判定有重复出现的子字符串; 即 字符串s % 最小重复单元x == 0；

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

#include<iostream>
#include<string>
using namespace std;

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) {
        //KMP
        if (s.size() == 0) {
            return false;
        }
        int* next = new int[s.size()];
        getNext(next, s);//前缀表赋值
        int len = s.size();
        //最长相等前后缀的长度为：next[len - 1]
        //最小重复单元的长度：len - (next[len - 1] )
        if (next[len - 1] != 0 && len % (len - (next[len - 1])) == 0) {
            return true;
        }
        return false;
    }
};

总结

1.暴力解法的终止位置是能整除的时候

2.移动匹配是两个字符串相合后去除首尾字符，再查找是否出现原字符串

3.KMP方法是也整除思想，前缀表不包含的那部分子串就是最小单元重复串，然后用原字符串长度 - 前缀表中最大长度的公共前后缀长度，即重复子串长度；然后整除，余数是否为0；