459. 重复的子字符串

题目描述：给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
解题思路一：循环遍历可以重复的长度，依次比较每个重复长度中对应的字符是否相等，只要可以成功匹配并遍历完整个数组，即返回True，否则返回False，代码如下：

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        size = len(s)
        if size == 1: return False
        for i in range(1, size // 2 + 1):
            if size % i == 0:
                c = size // i
                k = c
                for j in range(i, size):
                    if s[j] != s[j-i]:
                        break
                else:
                    return True
        return False

解题思路二：将两个s拼凑在一起并去除首字母和最后一个字母之后，s仍是拼凑字符串的子串，那么s就是满足要求的，详细证明见证明，代码如下：

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        return (s+s).find(s, 1) != len(s)

解题思路三：方法和二一样，不用库函数，直接用kmp算法实现，代码如下：

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        def buildnext(p):
            size = len(p)
            n = [-1] * size
            t = -1
            j = 0
            while(j < size - 1):
                if (t < 0 or p[j] == p[t]):
                    j += 1
                    t += 1
                    n[j] = t if p[j] != p[t] else n[t]
                else:
                    t = n[t]
            return n
        def kmp(s, p):
            n, m = len(s), len(p)
            i, j = 0, 0
            next_t = buildnext(p)
            while(i < n and j < m):
                if (j < 0 or s[i] == p[j]):
                    i += 1
                    j += 1
                else:
                    j = next_t[j]
            return (i - j) <= (n - m)
        return kmp((s+s)[1:-1], s)

解题思路四：优化kmp算法，因为kmp算法中构造的next表，n[j]的值等于s[:j]中前缀等于后缀的子串的最大长度，因此我们可以直接观察next表的最后一个值，对于满足题目要求的字符串s来说，len(s)-n[-1]-1应该就是重复子串 $t^{\prime }$的长度，只要len(t')是len(s)的约数就可以了，另外还要满足s[-1]=s[n[-1]]，因为这里的next表不只是用来做字符匹配，而是有实际的意义，因此这里就不能做像思路三种优化措施，代码如下：

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        def buildnext(p):
            size = len(p)
            n = [-1] * size
            t = -1
            j = 0
            while(j < size - 1):
                if (t < 0 or p[j] == p[t]):
                    j += 1
                    t += 1
                    n[j] = t
                    # n[j] = t if p[j] != p[t] else n[t]
                else:
                    t = n[t]
            return n
        n = buildnext(s)
        size = len(s)
        return n[-1] != -1 and s[n[-1]] == s[-1] and (size % (size - 1 - n[-1]) == 0)