算法随想录算法训练营Day09

Day09 KMP算法

一、KMP算法

KMP算法理论篇（视频）
KMP算法代码篇（视频）

前缀：指不包含最后一个字符的所有以第一个字符开头的连续子串。
后缀：指不包含第一个字符的所有以最后一个字符结尾的连续子串。
前缀表：起始位置到下标i之前（包括i）的子串中，有多大长度的相同前缀后缀。

二、力扣相关例题

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

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

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

解题关键：
结合KMP算法的过程理解

class Solution {
public:
    //构造getnext函数，填充next数组，记录最长相等子串
    void getnext(int* next, string& s) {
        //初始化next[0]=0
        //定义两个指针i和j，j指向前缀末尾位置，i指向后缀末尾位置。
        //next[i] 表示 i（包括i）之前最长相等的前后缀长度（其实就是j）,所以初始化next[0] = j
        int j = 0;
        next[0] = j;
        //遍历模式串s的循环下标i 要从 1开始，进行s[i] 与 s[j]的比较
        for (int i = 1; i < s.size(); i++) {
            //处理前后缀不相同的情况
            /*
            如果 s[i] 与 s[j]不相同，也就是遇到 前后缀末尾不相同的情况，就要向前回退。
            那怎么回退呢？
            next[j]就是记录着j（包括j）之前的子串的相同前后缀的长度。
            那么 s[i] 与 s[j] 不相同，就要找 j 前一个元素在next数组里的值（就是next[j-1]）
            */
            while (j > 0 && s[j] != s[i]) {
                j = next[j - 1];          
            }
            //处理前后缀相同的情况
            //如果 s[i] 与 s[j] 相同，那么就同时向后移动i 和j
            if (s[j] == s[i]) {
                j++;
            }
            //将j（前缀的长度）赋给next[i], 因为next[i]要记录相同前后缀的长度。
            next[i] = j;
        }
    }
    int strStr(string haystack, string needle) {
        int j = 0;
        int next[needle.size()];
        getnext(next, needle);
        for (int i = 0; i < haystack.size(); i++) {
            //如果 haystack[i] 与 needle[j] 不相同，j就要从next数组里寻找下一个匹配的位置。
            while (j > 0 && needle[j] != haystack[i]) {
                j = next[j - 1];
            }
            //如果 haystack[i] 与 needle[j] 相同，那么i 和 j 同时向后移动
            if (needle[j] == haystack[i]) {
                j++;
            }
            //说明needle已匹配完成
            if (j == needle.size()) {
                return i - needle.size() + 1;
            }
        }
        return -1;
    }
};

459. 重复的子字符串

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

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

注明：今天时间不太够，这道题我先保存，周日再AC
2023/4/16 19:29 来了来了

解题关键：
这道题有点难，思路难以想到，需不断巩固理解
如果len % (len - (next[len - 1] + 1)) == 0 ，则说明数组的长度正好可以被 (数组长度-最长相等前后缀的长度) 整除 ，说明该字符串有重复的子字符串。
数组长度减去最长相同前后缀的长度相当于是第一个周期的长度，也就是一个周期的长度，如果这个周期可以被整除，就说明整个数组就是这个周期的循环。
公式推导

class Solution {
public:
    //next数组获取最长相等前后缀
    void getnext (int* next, string& s) {
        int j = 0;
        next[0] = j;
        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) {
        //如果s字符串长度为0，则为false
        if (s.size() == 0) {
            return false;
        }
        int next[s.size()];
        getnext(next, s);
        int len = s.size();
        //这里通过数学公式推导，只要字符串长度%(字符长度-最长相等前后缀)==0，即为由子串重复组成
        if (next[len - 1] != 0 && len % (len - next[len - 1]) == 0) {
            return true;
        }
        return false;
    }
};

三、字符串总结

1. 双指针法是字符串处理的常客
2. KMP的主要思想是当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了

好难好难！理解了好久！
注：高数也好难