代码随想录算法训练营第9天 | 第四章 字符串part02

---

今日记录

---

KMP算法

解决的问题

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

前缀表

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

前缀和后缀

EX：模式串为 aabaaf
前缀有：a, aa, aab, aaba, aabaa
后缀有：f, af, aaf, baaf, abaaf

前缀：包含首字母，不包含尾字母的所有字串
后缀：包含尾字母，不包含首字母的所有字串（从后向前）

最长相等前后缀(相同前后缀的长度)：

a 最长相等前后缀：0
aa 最长相等前后缀：1(前: a 后:a)
aab 最长相等前后缀：0(前: a aa 后:b ab)
aaba 最长相等前后缀：1(前: a aa aab 后:a ba aba)
aabaa 最长相等前后缀：2(前: a aa aab aaba 后:a aa baa abaa)
aabaaf 最长相等前后缀：0(前: a aa aab aaba aabaa 后:f af aaf baaf abaaf)
前缀表：0 1 0 1 2 0
一般会减一为：-1 0 -1 0 1 -1
或者右移第一位补-1：-1 0 1 0 1 2
在处理时会不一样

next数组

就是前缀表，next就是要回退到的地方
构造next数组：

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

构造next数组其实就是计算模式串s，前缀表的过程。 主要有如下三步：
1.初始化
2.处理前后缀不相同的情况
3.处理前后缀相同的情况

1. 初始化
   定义两个指针i和j，j指向前缀末尾位置，i指向后缀末尾位置。
   然后还要对next数组进行初始化赋值，如下：

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

j 为什么要初始化为 -1呢，因为之前说过 前缀表要统一减一的操作仅仅是其中的一种实现，我们这里选择 j 初始化为 -1，下文我还会给出 j 不初始化为 -1 的实现代码。
next[ i ] 表示 i（包括 i）之前最长相等的前后缀长度（其实就是 j ）

EX:aabaaf next[4]表示aabaa最长相等前后缀，为2 = j

所以初始化next[0] = j 。

2. 处理前后缀不相同的情况
   因为 j 初始化为 -1，那么 i 就从1开始，进行s[ i ] 与 s[ j+1 ]的比较。
   所以遍历模式串s的循环下标 i 要从 1开始，代码如下：

while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
    j = next[j]; // 向前回退
}

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

代码如下：

if (s[i] == s[j + 1]) { // 找到相同的前后缀
    j++;
}
next[i] = j;

next总体代码：

void getNext(int* next, const string& s){
   int j = -1;
   next[0] = j;
   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;
   }
}

28.实现strStr()

Leetcode链接

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

代码实现

class Solution {
public:
    void getNext(int* next, const string& s) {
        int j = -1;
        next[0] = j;
        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;
        }
    }

    int strStr(string haystack, string needle) {
        if (needle.size() == 0) {
            return 0;
        }
        vector<int> next(needle.size());
        getNext(&next[0], needle);

        int j = -1;
        for (int i = 0; i < haystack.size(); i++) {
            while (j >= 0 && haystack[i] != needle[j + 1]) {
                j = next[j];
            }
            if (haystack[i] == needle[j + 1]) {
                j++;
            }
            if (j == (needle.size() - 1)) {
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }
};

459.重复的字符串

Leetcode链接

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

思路

在一个字符串中寻找是否出现过另一个串：KMP算法

最长相同前后缀和重复子串的关系：最长相等前后缀不包含的子串就是最小重复子串

如何找到最小重复子串

if len % ( len - ( next[ len-1 ]+1 ) ) == 0 进行判断

代码

class Solution {
public:
    void getNext(int* next, const string& s) {
        int j = -1;
        next[0] = j;
        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;
        vector<int> next(s.size());
        getNext(&next[0], s);
        int len = s.size();
        if (next[len - 1] != -1 && len % (len - (next[len - 1] + 1)) == 0) {
            return true;
        }
        return false;
    }
};

---

总结