代码随想录算法训练营day09 | 28. 实现 strStr()、459.重复的子字符串

28. 实现 strStr()

KMP算法

Carl的视频看了两遍，对于kmp算法了解的更深刻了，之前都是理论觉得懂了，实际代码不会。

字符串和模式串匹配的时候与求next数组思想是一样的，都是可以根据当前匹配字符的前面的字符的最长相等前后缀来进行下一步的移动

next数组落实到具体代码：

1. 初始化
2. 当前不匹配
3. 当前匹配
4. next数组赋值

代码中的i为后缀末尾，j为前缀末尾

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        # 特殊情况，needle为空的时候返回值，可以根据题意写
        if not needle:
            return 0
        next = [0] * len(needle)
        self.get_next(needle, next)
        # 不减一
        j = 0
        for i in range(0, len(haystack)):
            while j > 0 and haystack[i] != needle[j]:
                j = next[j-1]
            if haystack[i] == needle[j]:
                j += 1
            if j == len(needle):
                return i-len(needle)+1
        return -1

    # next数组不减一，数值即代表最长相等前后缀
    def get_next(self, s: str, next: List[int]) -> None:
        j = 0
        next[0] = j
        for i in range(1, len(s)):
            while j > 0 and s[i] != s[j]:
                j = next[j-1]
            if s[i] == s[j]:
                j += 1
            next[i] = j

459.重复的子字符串

本题可以直接使用库函数

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        # 使用find, s+s，去除第一位和最后一位，还能找到s说明有重复子串
        if len(s) <= 1:
            return False
        ss = s[1:] + s[:-1]
        return ss.find(s) != -1

也可以使用KMP算法来实现

除了求next的操作外，还有一个关键点在于如何判断是重复的子串

len % (len - next[len-1]) == 0 and 最后一位的最长相等前后缀不能是0

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        # 使用KMP算法，不减一的做法
        s_len = len(s)
        next = [0] * s_len
        self.get_next(s, next)

        # 关键点在于如何判断是重复的子串 len % (len - next[len-1]) == 0 并且最后一位的最长相等前后缀不能是0，否则没有任何意义
        return True if next[s_len-1] != 0 and s_len % (s_len - next[s_len-1]) == 0 else False

    def get_next(self, s, next):
        j = 0
        next[0] = j
        for i in range(1, len(s)):
            while j > 0 and s[i] != s[j]:
                j = next[j-1]
            if s[i] == s[j]:
                j += 1
            next[i] = j