leetcode_459(重复子串模式）

一、题目大意
给定一个非空字符串，判断它是否可以通过自身的子串重复若干次构成。你可以假设字符串只包含小写英文字母，并且长度不会超过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;ifor(int j=i+distance;jif(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//生成相同长度
                }
                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