一、題目大意
給定一個非空字串，判斷它是否可以通過自身的子串重複若干次構成。你可以假設字串只包含小寫英文字母，並且長度不會超過10000

二、分析
1， kmp模式匹配演算法，這是模式匹配最快的的演算法，複雜度是O(n)。
《KMP演算法的詳解》
2，方法二：若字串的長度為len，則重複子串的長度最長為len/2，可以遞減逐一判讀是否。
3，方法三：重複子串長度最長為len/2，直接每次選擇一個可以被整除的較小的數，擷取開頭的那幾個字元，然後重複到原長度驗證就好。

三，java實現2,3
1，方法二

public static boolean repeatedSubstringPattern(String str
 
) {
        int len = str.length();
        int i = 1;
        boolean flag = false;
        while(i<=len/2) {//逐一判斷
            if(len % i == 0) {
                flag = check(str,i);//當前長度可不可得到重複子串
            }
            i++;
            if(flag) break;
        }
        return flag;
    }

public
 
 static boolean check(String str,int distance) {//方法具體實現
        int len = str.length();
        for(int i=0;i<distance;i++) {
            for(int j=i+distance;j<len;j += distance) {
                if(str.charAt(i) != str.charAt(j))
                    return false;
            }
        }
        return
 
 true;
    }

2，方法三

public static boolean repeatedSubstringPattern2(String str) {
        int len = str.length();
        for(int i=1;i<=len/2;i++) {//最大長度
            if(len%i == 0) {
                String tem = str.substring(0, i);//子串
                StringBuffer sb = new StringBuffer();
                for(int j=0;j<len/i;j++) {
                    sb = sb.append(tem);//生成相同長度
                }
                if(sb.toString().equals(str))//驗證
                    return true;
            }
        }
        return false;
    } 

四、python實現方法1
記字串長度為size

利用KMP演算法求next陣列，記next陣列的最後一個元素為p

若p > 0 並且 size % (size - p) == 0，返回True

next陣列具有如下性質：

str[ 0 : next[i] ] == str[ i + 1 - next[i] : i + 1 ]

例如：

a, b, c, d, a, b, c, a, b, c, d, a, b, c, d, c

0, 0, 0, 0, 1, 2, 3, 1, 2, 3, 4, 5, 6, 7, 4, 0

class Solution(object):
    def repeatedSubstringPattern(self, str):
        """
        :type str: str
        :rtype: bool
        """
        size = len(str)
        next = [0] * size
        for i in range(1, size):
            k = next[i - 1]
            while str[i] != str[k] and k:
                k = next[k - 1]
            if str[i] == str[k]:
                next[i] = k + 1
        p = next[-1]
        return p > 0 and size % (size - p) == 0