这是悦乐书的第236次更新，第249篇原创

01 看题和准备

今天介绍的是LeetCode算法题中Easy级别的第103题（顺位题号是459）。给定非空字符串检查是否可以通过获取它的子字符串并将子字符串的多个副本附加在一起来构造它。 您可以假设给定的字符串仅由小写英文字母组成，其长度不超过10000。例如：

输入：“abab”
输出：true
说明：它是子串“ab”两次。

输入：“aba”
输出：false

输入：“abcabcabcabc”
输出：true
说明：它是子串“abc”四次。 （和子串“abcabc”两次。）

本次解题使用的开发工具是eclipse，jdk使用的版本是1.8，环境是win7 64位系统，使用Java语言编写和测试。

02 第一种解法

特殊情况：当s为null或者s的长度小于等于1时，直接返回false。

正常情况：从1开始，截取s的第0到第1位，然后使用StringBuilder类，累加截取的字符串组成新的字符串，然后比较新旧字符串是否相等，如果相等，直接返回true，反之，截取s的第0到第2位，继续之前的操作和判断。

在外层循环中，指针i是小于等于二分之s的长度的，因为子字符串至少要匹配一次，所以i是小于等于len/2的。在外层循环开始的时候，我们可以加多一步判断，省去没必要的计算，如果len对i取余不等于0，就结束当前循环，进入下一次循环。例如，len等于9，i则小于等于4，我们只用计算i等于1和3的情况即可，2和4是不可能满足子字符串要求的。

public boolean repeatedSubstringPattern(String s) {
    if (s == null || s.length() <= 1) {
        return false;
    }
    int len = s.length();
    for (int i=1; i<=len/2; i++) {
        if (len%i != 0) {
            continue;
        }
        String str = s.substring(0, i);
        StringBuilder sb = new StringBuilder();
        for (int j=0; j<len/i; j++) {
            sb.append(str);
        }
        if (s.equals(sb.toString())) {
            return true;
        }
    }
    return false;
}

03 第二种解法

特殊情况：当s为null或者s的长度小于等于1时，直接返回false。

正常情况：思路和第一种解法类似，只是将内层循环中使用StringBuilder类换成了截取字符串，每次从i开始，往后截取i个长度的子串，然后判断两个子串是否相等。

public boolean repeatedSubstringPattern2(String s) {
    if (s == null || s.length() <= 1) {
        return false;
    }
    int len = s.length();
    for (int i=1; i<=len/2; i++) {
        if (len%i != 0) {
            continue;
        }
        String str = s.substring(0, i);
        boolean flag = true;
        for (int j=i; j<len; j += i) {
            if (!str.equals(s.substring(j, j+i))) {
                flag = false;
                break;
            }
        }
        if (flag) {
            return true;
        }
    }
    return false;
}

04 第三种解法

此解法来自提交代码里排第一位置的，思路比较巧妙，利用了kmp算法，感兴趣的同学可以去看下CSDN上July大神的一篇介绍kmp算法的博文，传送门：https://blog.csdn.net/v_JULY_v/article/details/7041827

public boolean repeatedSubstringPattern3(String s) {
    int len = s.length();
    if (len < 2) {
        return false;
    }
    char lastChar = s.charAt(len-1);
    int index = s.indexOf(lastChar);
    // 思想是： 找到最后一个字符所在的位置，那么如果是pattern，则一定有
    // len％（index＋1）＝＝ 0。 那么pattern应该是从0到index位置的子串。
    while (index >=0 && index < len-1) {
        if (len % (index+1) == 0) {
            String pattern = s.substring(0, index+1);
            if (foundPattern(s, pattern)) {
                return true;
            } else {
                //否则找下一个出现lastChar的位置
                index = s.indexOf(lastChar, index+1);
            }
        } else {
            //否则找下一个出现lastChar的位置
            index = s.indexOf(lastChar, index+1);
        }
    }
    return false;  
}

private boolean foundPattern(String s, String pattern) {
    int fromIndex = pattern.length();
    int n = fromIndex;
    while (fromIndex < s.length()) {
        if (!pattern.equals(s.substring(fromIndex, fromIndex + n))) {
            return false;
        }
        fromIndex += fromIndex;
    }
    return true;
}

05 第四种解法

还有更加疯狂的解法，两行代码搞定。方法是将s和自身连接组成一个新的字符串，然后从第二位开始，截取子字符串到倒数第二位，得到的子字符串再去判断是否包含s字符串序列。

思路是这样的，如果s是由可连续的子串组成，那么将其重复一遍后，重复子串的数量是原来的2倍，再将其去头去尾，那么中间至少会存在一个完整的s，如果s是由单字母组成，就会存在多个s。反之，如果s不是由连续子串组成，在进行上面的操作后，中间部分是不可能存在s的，因为不具备连续性，再重复一遍的新字符串肯定也不具备连续性。

此解法的时间复杂度不是O(1)，因为使用了contains方法，时间复杂度好的情况是O(n)，坏的情况是O(n^2)。

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

06 小结

算法专题目前已日更超过三个月，算法题文章103+篇，公众号对话框回复【数据结构与算法】、【算法】、【数据结构】中的任一关键词，获取系列文章合集。

以上就是全部内容，如果大家有什么好的解法思路、建议或者其他问题，可以下方留言交流，点赞、留言、转发就是对我最大的回报和支持！