代码随想录算法训练营第九天|28. 找出字符串中第一个匹配项的下标

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

思路：

本题是KMP 经典题目（在一个串中查找是否出现过另一个串，这是KMP的看家本领）

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

2.KMP有什么用：KMP主要应用在字符串匹配上。KMP的主要思想是当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。所以如何记录已经匹配的文本内容，是KMP的重点，也是next数组肩负的重任。

3.什么是前缀表：写过KMP的同学，一定都写过next数组，next数组就是一个前缀表（prefix table）。前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。

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

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

4.最长公共前后缀：文章中字符串的前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。正确理解什么是前缀什么是后缀很重要!

用“最长相等前后缀” 比“最长公共前后缀”更准确一些。因为前缀表要求的就是相同前后缀的长度。而最长公共前后缀里面的“公共”，更像是说前缀和后缀公共的长度。这其实并不是前缀表所需要的。

例子：每次取相同长度的前后缀子串对比是否相同，存在就返回前后缀子串长度，不存在都是0.
a：前后缀都为0，长度为0；
aa：前后缀都为a，长度为1；
aab：前缀aa，后缀ab，不相同，再取前缀a，后缀b，不相同，长度为0；
aaba：前缀aab，后缀aba，不相同，再取前缀aa，后缀ba，不相同，再取前缀a，后缀a，相同，长度为1；
aabaa：前缀aaba，后缀abaa，不相同，再取前缀aab，后缀baa，不相同，再取前缀aa，后缀aa，相同，长度为2；
aabaaf：前缀aabaa，后缀abaaf，不相同，再取前缀aaba，后缀baaf，不相同，再取前缀aab，后缀aaf，不相同，再取前缀aa，后缀af，不相同，再取前缀a，后缀f，不相同，长度为0.

代码： 

暴力法

class Solution(object):
    def strStr(self, haystack, needle):
        """
        :type haystack: str
        :type needle: str
        :rtype: int
        """
        m, n = len(haystack), len(needle)
        for i in range(m):
            if haystack[i:i+n] == needle:
                return i
        return -1   

• 时间复杂度: O(n×m)，其中 n是字符串 haystack的长度，m是字符串 needle 的长度。最坏情况下我们需要将字符串 needle与字符串 haystack的所有长度为 m的子串均匹配一次。
• 空间复杂度: O(1)，我们只需要常数的空间保存若干变量。

KMP算法，前缀表（不减一） 

class Solution:
    def getNext(self, next: List[int], s: str) -> None:
        j = 0 # j代表前缀末尾位置
        next[0] = 0
        for i in range(1, len(s)): # i代表后缀末尾位置
            while j > 0 and s[i] != s[j]: # 处理前后缀不相同的情况
                j = next[j - 1] # j向前回退
            if s[i] == s[j]: # 前后缀相同的情况
                j += 1
            next[i] = j # 更新next数组的值，j表示最长相等前后缀
    
    def strStr(self, haystack: str, needle: str) -> int:
        if len(needle) == 0:
            return 0
        next = [0] * len(needle)
        self.getNext(next, needle)
        j = 0
        for i in range(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

• 时间复杂度: O(n + m)，其中 n是字符串 haystack的长度，m是字符串 needle的长度。我们至多需要遍历两字符串一次。
• 空间复杂度: O(m)，其中 m是字符串 needle的长度。

KMP算法，前缀表（减一） 

class Solution:
    def getNext(self, next, s):
        j = -1
        next[0] = j
        for i in range(1, len(s)):
            while j >= 0 and s[i] != s[j+1]:
                j = next[j]
            if s[i] == s[j+1]:
                j += 1
            next[i] = j
    
    def strStr(self, haystack: str, needle: str) -> int:
        if not needle:
            return 0
        next = [0] * len(needle)
        self.getNext(next, needle)
        j = -1
        for i in range(len(haystack)):
            while j >= 0 and haystack[i] != needle[j+1]:
                j = next[j]
            if haystack[i] == needle[j+1]:
                j += 1
            if j == len(needle) - 1:
                return i - len(needle) + 1
        return -1