Leetcode的AC指南 —— 字符串：459. 重复的子字符串

摘要：
**Leetcode的AC指南 —— 字符串：459. 重复的子字符串 **。题目介绍：给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

文章目录

一、题目
二、解析（go语言版）
1、KMP的next数组
2、移动匹配(KMP)

三、其他语言版本
Java
C++
Python

一、题目

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

力扣题目链接

示例 1:

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

示例 2:

输入: s = "aba"
输出: false

示例 3:

输入: s = "abcabcabcabc"
输出: true
解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)

提示：
1 <= s.length <= 104
s 由小写英文字母组成

二、解析（go语言版）

1、KMP的next数组

这里再重新理解下next数组，它表示的是最长相等前后缀长度。在 i 处遇到元素不相等时，通过next[i]的值来下次开始比较的位置。
举例：

下标	0	1	2	3	4	5	6	7	8	9	10	11
字符串	a	f	b	c	a	f	b	c	a	f	b	T
next数组	0	0	0	0	1	2	3	4	5	6	7	0

当 i=10 ，j = 6时，此时字符相等，则 j++ ，next[10] = j = 7
当 i=11， j = 7时，此时字符不相等，则 j = next[ j - 1 ] = 3
下一次比较从下标3 和下标11 开始
- 因为next数组记录了最长相等前后缀长度，可以发现下标0、1、2等于下标4、5、6，这个信息在next数据已经记录过了，我们可以直接跳过匹配字符串的前缀进行接下来的比较。

关于一个字符串s是否可以由多个子串重复构成，这个可以查看s的前缀表，也就是next数组。

s的最长相等前后缀长度是 next数组的最后一个元素。
观察next数组，数组长度减去最长相同前后缀的长度相当于是第一个周期的长度，也就是一个周期的长度，如果这个周期可以被整除，就说明整个数组就是这个周期的循环


package mainimport ("fmt"
)func main() {for {//var h string//fmt.Scanln(&h)var n stringfmt.Scanln(&n)fmt.Println(repeatedSubstringPattern(n))}}
func repeatedSubstringPattern(s string) bool {n := len(s)next := make([]int, n)j := 0next[0] = 0for i := 1; i < n; i++ {for j > 0 && s[i] != s[j] {j = next[j-1]}if s[i] == s[j] {j++}next[i] = j}fmt.Println("next:", next)if next[n-1] != 0 && n%(n-next[n-1]) == 0 {return true}return false
}

时间复杂度O(n)
空间复杂度O(n)

2、移动匹配(KMP)

思路：

若字符串s是重复的，则在s+s的拼接处一定还存在一个s。
为了避免搜索出原来的s，去除s+s的首尾字符。
判断一个字符串中是否出现另一个字符串，参考 28.实现strStr


func repeatedSubstringPattern(s string) bool {// 在两个s的拼接处，查找s是否出现过h := s + sh = h[1 : len(h)-1] // 防止找到开头和结尾的s// 构造next数组next := make([]int, len(s))j := 0next[0] = 0for i := 1; i < len(s); i++ {for j > 0 && s[i] != s[j] {j = next[j-1]}if s[i] == s[j] {j++}next[i] = j}j = 0for i := 0; i < len(h); i++ {for j > 0 && h[i] != s[j] {j = next[j-1]}if h[i] == s[j] {j++}if j == len(s) {return true}}return false
}

三、其他语言版本

Java

class Solution {public boolean repeatedSubstringPattern(String s) {if (s.equals("")) return false;int len = s.length();// 原串加个空格(哨兵)，使下标从1开始，这样j从0开始，也不用初始化了s = " " + s;char[] chars = s.toCharArray();int[] next = new int[len + 1];// 构造 next 数组过程，j从0开始(空格)，i从2开始for (int i = 2, j = 0; i <= len; i++) {// 匹配不成功，j回到前一位置 next 数组所对应的值while (j > 0 && chars[i] != chars[j + 1]) j = next[j];// 匹配成功，j往后移if (chars[i] == chars[j + 1]) j++;// 更新 next 数组的值next[i] = j;}// 最后判断是否是重复的子字符串，这里 next[len] 即代表next数组末尾的值if (next[len] > 0 && len % (len - next[len]) == 0) {return true;}return false;}
}

C++

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

Python

class Solution:def repeatedSubstringPattern(self, s: str) -> bool:  if len(s) == 0:return Falsenxt = [0] * len(s)self.getNext(nxt, s)if nxt[-1] != 0 and len(s) % (len(s) - nxt[-1]) == 0:return Truereturn Falsedef getNext(self, nxt, s):nxt[0] = 0j = 0for i in range(1, len(s)):while j > 0 and s[i] != s[j]:j = nxt[j - 1]if s[i] == s[j]:j += 1nxt[i] = jreturn nxt