重复的子字符串--kmp解法

题目链接:重复的子字符串
题目描述：
给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。

示例 1:

输入: “abab”

输出: True

解释: 可由子字符串 “ab” 重复两次构成。

示例 2:

输入: “aba”

输出: False

示例 3:

输入: “abcabcabcabc”

输出: True

解释: 可由子字符串 “abc” 重复四次构成。 (或者子字符串 “abcabc” 重复两次构成。)

解题思路
如果您的字符串 S 包含一个重复的子字符串，那么这意味着您可以多次 “移位和换行”`您的字符串，并使其与原始字符串匹配。
例如：abcabc
移位一次：cabcab
移位两次：bcabca
移位三次：abcabc
现在字符串和原字符串匹配了，所以可以得出结论存在重复的子串。
基于这个思想，可以每次移动k个字符，直到匹配移动 length - 1 次。但是这样对于重复字符串很长的字符串，效率会非常低。在 LeetCode 中执行时间超时了。
为了避免这种无用的环绕，可以创建一个新的字符串 str，它等于原来的字符串 S 再加上 S 自身，这样其实就包含了所有移动的字符串。
比如字符串：S = acd，那么 str = S + S = acdacd
acd 移动的可能：dac、cda。其实都包含在了 str 中了。就像一个滑动窗口，一开始 acd (acd) ，移动一次 ac(dac)d，移动两次 a(cda)cd。循环结束
所以可以直接判断 str 中去除首尾元素之后，是否包含自身元素。如果包含。则表明存在重复子串。
代码：
简化版：

class Solution {
   public boolean repeatedSubstringPattern(String s) {
        String str = s + s;
        return str.substring(1, str.length() - 1).contains(s);
}
}

对于查找子串是否存在问题可以套KMP

class Solution {
    static int[] get_next(String p){//生成next数组，
        int len = p.length();
        int[] next = new int[len+1];
        next[0] = -1;
        int k = -1,j = 0;
        while(j < len){//防止next[j]越界
            if(k==-1||p.charAt(k)==p.charAt(j)){//如果模式串指针回到了起点或者找到匹配位置
                k++;
                j++;
                next[j] = k;//存储当前的最大前后缀长度
            }else{
                k = next[k];//不匹配，将模式串右移
            }
        }
        return  next;
    }
    static int kmp(String s,String p,int[] next){//过程原理和 get_next一样
        int s_len = s.length();
        int p_len = p.length();
        int i = 0,j = 0;
        while(i < s_len&&j < p_len){
            if(j==-1||s.charAt(i)==p.charAt(j)){
                i++;
                j++;
            }else{
                j = next[j];//即将模式串右移了（j-next[j])位
            }
        }
        if(j >= p_len)
            return i - j;
        else
            return -1;
    }
       public boolean repeatedSubstringPattern(String s) {
        String str = s + s;
        return kmp(str.substring(1,str.length()-1),s,get_next(s)) != -1;
  }
}

kmp优化版本
next数组可以得出当前字符串的最大前后缀长度，如果s是循环字符串，那么next[len]一定是它最大循环字符子串的长度，总的字符串长度一定是循环子串长度的倍数，此时只要我们只要判断len能否被len - next[len]整除即可

class Solution {
    static int[] get_next(String p){
        int len = p.length();
        int[] next = new int[len+1];
        next[0] = -1;
        int k = -1,j = 0;
        while(j < len){
            if(k==-1||p.charAt(k)==p.charAt(j)){
                k++;
                j++;
                next[j] = k;
            }else{
                k = next[k];
            }
        }
        return  next;
    }
       public boolean repeatedSubstringPattern(String s) {
        int[] next = get_next(s);
        int n = s.length();
        int maxLen = next[n];
        if(maxLen == 0) return false;      
        return n%(n-maxLen)==0;
  }
}

变式：输出字符串的最小循环节
思路：基于以上思路，满足条件的时候的输出即可

class Solution {
    static int[] get_next(String p){
        int len = p.length();
        int[] next = new int[len+1];
        next[0] = -1;
        int k = -1,j = 0;
        while(j < len){
            if(k==-1||p.charAt(k)==p.charAt(j)){
                k++;
                j++;
                next[j] = k;
            }else{
                k = next[k];
            }
        }
        return  next;
    }
    public static void main(String[] args){
        String p = "aabaaba";
        int l = p.length();
        int[] next = get_next(p);
        int maxLen = next[l];
        int te  = l - maxLen;
        if(l%te==0) {
            for (int i = 0; i < maxLen; i++) {
                System.out.print(p.charAt(i));
            }
        }
    }
}