代码随想录算法训练营第九天 | ●28. 实现 strStr()●459.重复的子字符串●字符串总结 ●双指针回顾

文章目录

• 前言
• 一、28. 实现 strStr()
• 二、459.重复的子字符串
• 总结

---

前言

• 构造next数组其实就是计算模式串s，前缀表的过程

• 主要有如下三步：初始化；处理前后缀不相同的情况；处理前后缀相同的情况

• 对于next数组的应用，可以分为直接使用，数组整体右移一位以及整体减一 三种思路。其本质上是一样的。

---

一、实现 strStr() // 使用KMP算法

在 getNext 函数中，

           while(j>0 && s.charAt(i) != s.charAt(j)){
                j = next[j-1];

            }

不能直接让j=0,这里更重要的是，“j代表前后缀的最长相等长度”，因而需要找到这个位置。

j=0 指的是如“aab”，但并不全面，比如“abab”就算是让j没有退回到0的位置，这里只是用作说明j要进行回退的用意。

class Solution {

    public void getNext(int[] next,String s){
        int j = 0;
        next[0] = 0;
        for(int i = 1;i<s.length();i++){
            while(j>0 && s.charAt(i) != s.charAt(j)){
                j = next[j-1];//不能直接让j=0,这里更重要的是
                //“j代表前后缀的最长相等长度”，因而需要找到这个位置
            }
            if(s.charAt(j) == s.charAt(i)){
                j++;
            }
            next[i] = j;
        }
    }

    public int strStr(String haystack, String needle) {
        if(needle.length() == 0 ) return 0;
        int[] next = new int[needle.length()];
        getNext(next,needle);//注意，这里是needle的；

        int j = 0;
        for(int i = 0;i<haystack.length();i++){
            while(j>0 && needle.charAt(j) != haystack.charAt(i)){
                j = next[j - 1];
            }
            if(needle.charAt(j) == haystack.charAt(i)){
                j++;
            }
            if(needle.length() == j){
                return i-needle.length() + 1;
            }
        }
        return -1;
    }
}

二、459.重复的子字符串

暴力解法：

 也就是说，从第一个字符开使，每一次增加一个字符去循环判断，循环到子串小于等于字符串的  中间位置即可。

移动匹配：

下面的插图的证明思路来自视频下方@东坡泪的证明：

 

 

kmp算法：

• 前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串；
• 后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串

设字符串 abababab, next数组为 0 0 1 2 3 4 5 6，前缀{a,ab,aba,abab,ababa,ababab,abababa}, 后缀{b,ab,bab,abab,babab,ababab,bababab}，因此最长相同前后缀为ababab；

此外，最小重复子串由 绿前两个ab = 黄前两个ab,而黄前两个ab和绿第三四个ab都在字符串的同一位置，因此相等，即：黄前两个ab = 绿第三四个ab，得出：绿前两个ab = 绿第三四个ab，因此最小重复子串为“最长相等前后缀不包含的子串”。

 

• 假设字符串s使用多个重复子串构成（这个子串是最小重复单位），重复出现的子字符串长度是x，所以s是由n * x组成。

  因为字符串s的最长相同前后缀的长度一定是不包含s本身，所以 最长相同前后缀长度必然是m * x，而且 n - m = 1，（这里如果不懂，看上面的推理）

  所以如果 nx % (n - m)x = 0，就可以判定有重复出现的子字符串。

• 最长相等前后缀的长度为：next[len - 1] + 1。数组长度为：len。

  如果len % (len - (next[len - 1] + 1)) == 0 ，则说明数组的长度正好可以被 (数组长度-最长相等前后缀的长度) 整除 ，说明该字符串有重复的子字符串。

• 数组长度减去最长相同前后缀的长度相当于是第一个周期的长度，也就是一个周期的长度，如果这个周期可以被整除，就说明整个数组就是这个周期的循环。

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        if (s.equals("")) return false;

        int len = s.length();
        // 原串加个空格(哨兵)，使下标从1开始，这样j从0开始，也不用初始化了
        s = " " + s;
        char[] chars = s.toCharArray();
        int[] next = new int[len + 1];

        // 构造 next 数组过程，j从0开始(空格)，i从2开始
        for (int i = 2, j = 0; i <= len; i++) {
            // 匹配不成功，j回到前一位置 next 数组所对应的值
            while (j > 0 && chars[i] != chars[j + 1]) j = next[j];
            // 匹配成功，j往后移
            if (chars[i] == chars[j + 1]) j++;
            // 更新 next 数组的值
            next[i] = j;
        }

        // 最后判断是否是重复的子字符串，这里 next[len] 即代表next数组末尾的值
        if (next[len] > 0 && len % (len - next[len]) == 0) {
            return true;
        }
        return false;
    }

}

---

总结

复习。