LeetCode - 686 -重复叠加字符串匹配 -Java

题目

---

 

暴力解法

运用 StringBuilder 和 indexOf 来解决问题
StringBuilder 用来 存储存储 字符串 a 的叠加结果。
indexOf 用来 检查 字符串 a 重叠后 的 结果里 是否包含 子串 b。

---

 

代码

class Solution {
    public int repeatedStringMatch(String a, String b) {
        StringBuilder sb = new StringBuilder();
        int result = 0;   // 记录 重复叠加

      // 重复叠加， 如果 主串 还没有 子串长，那么，主串a 是不可能包含子串 b de
        while(sb.length() < b.length() && ++result>0 ){
            sb.append(a);
        }
        sb.append(a);// 主串 “a” 跟 子串b，在经过上面的叠加，主串长度 >= 子串长度
        // 但是 并不意味着：此时的主串就包含子串，所以 我们自行叠加了一次。

// 获取 子串b 在主串中的 初始位置下标 / 子串 b 的第一个字符， 在主串中出现位置的下标
        int index = sb.indexOf(b);
        if(index == -1){ // 要知道下标是不可能为负的，所以，-1 代表 主串中不包含子串
            return -1;// 按照题目的要求： 返回 -1.
        }
        
        return index + b.length() > a.length()* result ? result+1 : result;
// 在返回的时候：你会发现我们 让 index 和 子串长度相加，再去判断 和 主串 谁长。
// 至于为什么 子串长度 要加上 index，你可以这么想： index 的位置 是 子串在主串中 第一次出现的位置下标
// 那么，就是说： 如果主串包含子串， 主串 至少比 子串 长 index。
// 但是！ 想想看 如果我们子串长度 加上了这个长度，按道理 主串 和 子串 之间，只存在 长度相等，或 子串比主串短。
//  结果却是 大于！就是说 我们叠加次数少了！
// 但是！为何 主串能找到 子串，照理说应该是找不到的。
// 注意到我们前面 while 循环 后面，我们手动 叠加的那一下吗？
// 就是为了防止 出现 这种情况。 
// 所以返回值 result + 1 ： 意味着叠加次数加一
    }
}

附图

---

 

KMP 算法，可参考请收好这一封 KMP 算法 的信 - Java 和 c 实现这篇文章

class Solution {
    public int repeatedStringMatch(String a, String b) {
        StringBuilder sb = new StringBuilder();
        int result = 0;
        while(sb.length() < b.length() && ++result > 0){
            sb.append(a);
        }
        sb.append(a);
        int index = KMP(sb.toString(),b,0); 
        if(index == -1){
            return -1;
        }
        return index + b.length() > a.length()*result ? result+1 : result;
    }
    public static int KMP(String str,String sub,int pos){
        if(str == null || sub == null){
            return -1;
        }
        if(str.length() == 0 || sub.length() == 0){
            return -1;
        }
        int strLen = str.length();
        int subLen = sub.length();
        if(pos<0 || pos >= strLen){
            return -1;
        }

        int i = pos;
        int j = 0;
        
        int[] next = new int[subLen];
        getNext(sub,next);
        while( i < strLen && j < subLen){
            if(j == -1 || str.charAt(i) == sub.charAt(j)){
                i++;
                j++;
            }else{
                j = next[j];
            }
        }
        if(j >= subLen){
            return i-j;
        }
        return -1;
    }

    public static void getNext(String sub, int[] next){
        next[0] = -1;
        // next[1] = 0;看完过推荐文章，这里是要省略的。因为 子串可能只有一个字符，如果加上这句代码就会发生越界异常
        int k = -1;
        int j = 1;
        while( j < sub.length()){
            if(k == -1 || sub.charAt(j-1) == sub.charAt(k)){
                next[j] = k+1;
                k++;
                j++;
            }else{
                k =  next[k];
            }
        }
    }
}