Repeated Substring Pattern

问题：

Given a non-empty string check if it can be constructed by taking a substring of it and appending multiple copies of the substring together. You may assume the given string consists of lowercase English letters only and its length will not exceed 10000.

Example 1:

Input: "abab"
Output: True
Explanation: It's the substring "ab" twice.

Example 2:

Input: "aba"
Output: False

Example 3:

Input: "abcabcabcabc"
Output: True
Explanation: It's the substring "abc" four times. (And the substring "abcabc" twice.)

解决：

① 给定一个字符串，问其是否能拆成n个重复的子串。那么既然能拆分成多个子串，那么每个子串的长度肯定不能大于原字符串长度的一半，那么我们可以从原字符串长度的一半遍历到1，如果当前长度能被总长度整除，说明可以分成若干个子字符串，我们将这些子字符串拼接起来看跟原字符串是否相等。 如果拆完了都不相等，返回false。

public class Solution {//76ms
public boolean repeatedSubstringPattern(String s) {
int len = s.length();
for (int i = len / 2;i >= 1 ;i -- ) {
if (len % i == 0) {
int k = len / i;
StringBuilder sb = new StringBuilder();
for (int j = 0;j < k ;j ++ ) {//遍历k个子串
sb.append(s.substring(0,i));
}
if(sb.toString().equals(s)) return true;
}
}
return false;
}
}

进化版：

public class Solution {
public boolean repeatedSubstringPattern(String s) {
int len = s.length();
for (int i = len / 2; i >= 1; i --) {
if (len % i == 0) {
int k = len / i;
String sub = s.substring(0,i);
int j = 1;
for (;j < k;j ++) {
if (! sub.equals(s.substring(i * j, i * j + i))) break;
}
if (j == k) {
return true;
}
}
}
return false;
}
}

② 在discuss中看到了这个，效率最高。不知道为什么只需要计算1/2和1/3，然后考虑奇数个字符就可以了。

public class Solution {//10ms
public boolean repeatedSubstringPattern(String s) {
if (s == null || s.length() <= 1) return false;
int len = s.length();
int mid = len / 2;//一半
if (s.substring(0, mid).equals(s.substring(mid))) return true;
int one_third = len / 3;//三分之一
String sub = s.substring(0, one_third);
if (sub.equals(s.substring(one_third, one_third * 2))
&& sub.equals(s.substring(one_third * 2))) return true;
if (len % 2 == 1) {//奇数个字符
char c = s.charAt(0);
for (int i = 1; i < len; i ++) {
if (s.charAt(i) != c) return false;
}
return true;
}
return false;
}
}

③ 类似kmp算法，然而我并没有看懂。。。以后再看吧。O（n）

public class Solution {//17ms
public boolean repeatedSubstringPattern(String s) {
int[] prefix = kmp(s);
int len = prefix[s.length() - 1];
int n = s.length();
return (len > 0 && n % (n - len) == 0);
}
private int[] kmp(String s){
int len = s.length();
int[] res = new int[len];
char[] schar = s.toCharArray();
int i = 0;
int j = 1;
res[0] = 0;
while(i < schar.length && j < schar.length){
if(schar[i] == schar[j]){
res[j] = i + 1;
i ++;
j ++;
}else{
if(i == 0){
res[j] = 0;
j ++;
}else{
i = res[i - 1];
}
}
}
return res;
}
}