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

28. 找出字符串中第一个匹配项的下标

代码随想录

视频(理论)

视频(代码)

KMP

KMP主要应用在字符串匹配上

当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了

时间复杂度:O(n+m)

前缀表

next数组就是一个前缀表（prefix table）

前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。

eg: 要在文本串：aabaabaafa 中查找是否出现过一个模式串：aabaaf。

使用前缀表，就不会从头匹配，而是从上次已经匹配的内容开始匹配，找到了模式串中第三个字符b继续开始匹配

什么是前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀

前缀表的元素值：1. 下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀 2. 如果i + 1的元素不匹配 则需要跳转到 下标i的元素值(新的下标) 再进行匹配

最长公共前后缀

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

后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。

因为前缀表要求的就是相同前后缀的长度

例如：字符串aa的最长相等前后缀为1。 字符串aaa的最长相等前后缀为2。

前缀表的作用

eg:

刚刚匹配的过程在下标5的地方遇到不匹配，模式串是指向f

然后就找到了下标2，指向b，继续匹配

下标5之前这部分的字符串（也就是字符串aabaa）的最长相等的前缀 和 后缀字符串是 子字符串aa ，因为找到了最长相等的前缀和后缀，匹配失败的位置是后缀子串的后面，那么我们找到与其相同的前缀的后面从新匹配就可以了

所以前缀表具有告诉我们当前位置匹配失败，跳到之前已经匹配过的地方的能力

如何计算前缀表

推荐视频

里面的图解很好理解，了解匹配思想，就可以代入我们定义的前缀表

本人代码

class Solution {
    public int strStr(String haystack, String needle) {
        int[] next = getNext(needle);
        int j = 0;
        System.out.println(Arrays.toString(next));
        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(j == next.length){
                return i - needle.length() + 1;
            }
        }
        return -1;
    }



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

代码随想录代码

class Solution {
    //前缀表（不减一）Java实现
    public int strStr(String haystack, String needle) {
        if (needle.length() == 0) return 0;
        int[] next = new int[needle.length()];
        getNext(next, 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 (j == needle.length()) 
                return i - needle.length() + 1;
        }
        return -1;

    }
    
    private 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(j) != s.charAt(i)) 
                j = next[j - 1];
            if (s.charAt(j) == s.charAt(i)) 
                j++;
            next[i] = j; 
        }
    }
}

459. 重复的子字符串

代码随想录

视频

思路

移动匹配

当一个字符串s：abcabc，内部又重复的子串组成，那么这个字符串的结构一定是这样的：

也就是又前后又相同的子串组成。

那么既然前面有相同的子串，后面有相同的子串，用 s + s，这样组成的字符串中，后面的子串做前串，前后的子串做后串，就一定还能组成一个s，如图：

所以判断字符串s是否有重复子串组成，只要两个s拼接在一起，里面还出现一个s的话，就说明是又重复子串组成。

当然，我们在判断 s + s 拼接的字符串里是否出现一个s的的时候，要刨除 s + s 的首字符和尾字符，这样避免在s+s中搜索出原来的s，我们要搜索的是中间拼接出来的s。

KMP

在由重复子串组成的字符串中，最长相等前后缀不包含的子串就是最小重复子串，这里那字符串s：abababab 来举例，ab就是最小重复单位，如图所示：

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

具体推理可看代码随想录

本人代码

移动匹配

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

KMP

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        int[] next = getNext(s);
        if(next[s.length() - 1] == 0 || s.length() % (s.length() - next[s.length() - 1]) != 0){
            return false;
        }
        return true;
    }

    public int[] getNext(String s){
        int[] next = new int[s.length()];
        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];
            }
            if(s.charAt(i) == s.charAt(j)){
                j++;
            }
            next[i] = j;
        }
        return next;
    }
}

代码随想录代码

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;
    }
}

字符串：总结篇

代码随想录

看代码随想录回顾

双指针总结

代码随想录

看代码随想录回顾