Day19（字符串）-优快云博客

本文链接：https://blog.youkuaiyun.com/Glorious01/article/details/146190340

💫好难啊，为什么做事情很难坚持呢，动力不足，不知道该怎么办，也不是迷茫，就是做事没劲。

💫KMP...感觉理解了但又感觉没理解，过段时间再回来看吧... 2025年3月11日21:58:18

📆学习日期：2025年3月11日14:00:57

💻学习内容：实现strStr() | KMP 算法 | 重复的子字符串

⏲️学习时长：4h

练习题目- 字符串匹配项（KMP算法)

题目描述

28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）简单 (ˉ▽ˉ；)...一点都不简单

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

示例 1：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

示例 2：

输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。

提示：

1 <= haystack.length, needle.length <= 104
haystack 和 needle 仅由小写英文字符组成

解题思路

整体思路&&注意事项

代码实现

getNext()函数获取前缀表
在主函数中利用此前缀表进行匹配

Bug

class Solution {
public:

    //求next数组，本身就是KMP
    void getNext(int *next,const string &s){
        int j=0;                                  
        next[0]=0;//初始化，j为0，i为1

        for(int i=1;i<s.size();i++){//i表示后缀尾，利用i遍历模式串，找到最长相等前后缀，计算next数组
            while(j>0&&s[i]!=s[j]){//前后缀不匹配，j需要回退，一直回退到上一次匹配或者初始                    
                j=next[j-1];
            }
            if(s[i]==s[j]){//前后缀匹配
                j++;
            }
            next[i]=j;//更新next数组，j就是位置以i为结尾的子串的最长相等前后缀
        }
    }

    int strStr(string haystack, string needle) {//利用next数组做字符串匹配
        if(needle.size()==0){
            return 0;//空字符串，返回0
        }

        vector<int> next(needle.size());//定义next数组
        getNext(&next[0],needle);//调用函数求needle串的前缀表

        int j=0;
        for(int i=0;i<haystack.size();i++){
            while(j>0&&haystack[i]!=needle[j]){//不匹配
                j=next[j-1];//回退
            }
            if(haystack[i]==needle[j]){
                j++;
            }

            if(j==needle.size()){//j为模式串长度，表示匹配成功
                return(i-needle.size()+1);//返回匹配下标
            }
        }
        
        return -1;//未找到匹配子串，返回-1；

        
    }
};

class Solution {
public:
    void getNext(int* next, const string& s) {
        int j = -1;
        next[0] = j;
        for(int i = 1; i < s.size(); i++) { // 注意i从1开始
            while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
                j = next[j]; // 向前回退
            }
            if (s[i] == s[j + 1]) { // 找到相同的前后缀
                j++;
            }
            next[i] = j; // 将j（前缀的长度）赋给next[i]
        }
    }
    int strStr(string haystack, string needle) {
        if (needle.size() == 0) {
            return 0;
        }
		vector<int> next(needle.size());
		getNext(&next[0], needle);
        int j = -1; // // 因为next数组里记录的起始位置为-1
        for (int i = 0; i < haystack.size(); i++) { // 注意i就从0开始
            while(j >= 0 && haystack[i] != needle[j + 1]) { // 不匹配
                j = next[j]; // j 寻找之前匹配的位置
            }
            if (haystack[i] == needle[j + 1]) { // 匹配，j和i同时向后移动
                j++; // i的增加在for循环里
            }
            if (j == (needle.size() - 1) ) { // 文本串s里出现了模式串t
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }
};

练习题目2-重复的子字符串

题目描述

459. 重复的子字符串 - 力扣（LeetCode）简单(ˉ▽ˉ；)...一点都不简单

给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

示例 1:

输入: s = "abab"
输出: true
解释: 可由子串 "ab" 重复两次构成。

示例 2:

输入: s = "aba"
输出: false

示例 3:

输入: s = "abcabcabcabc"
输出: true
解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)

提示：

1 <= s.length <= 104
s 由小写英文字母组成

解题思路

整体思路&&注意事项

暴力解法

外层for循环子串结束位置（起始位置必定是从第一个开始，否则讨论没有意义），内层for循环遍历主串，判断是否可以由子串重复多次构成。疑问
遍历的时候只需要遍历到中间位置，因为子串结束位置大于中间位置的话，一定不能重复组成字符串。

移动匹配解法

字符串s，拼接成新的字符串s+s，删掉头尾元素之后，在s+s中搜索s，若找到了s，则说明字符串s是由重复子串构成的。
证明过程：代码随想录
在字符串中寻找子串的操作是上一题：28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）
可利用库函数find(),contain()等字符串|string

str.find("ah"); // 返回str中字符串 "ah" 首次出现的位置 str.find(string s, size_type n=0)// 如果没找到则返回 -1

利用了字符串本身的特点

KMP解法

结论：若一个字符串由重复子串构成，则最长相等前后缀不包含的部分，就是重复字符串的最小单位。
推导：代码随想录
最长相等前后缀不包含的子串的长度只要被字符串s的长度整除，最长相等前后缀不包含的子串一定是最小重复子串。关键

KMP算法，最长相等前后缀

代码实现

Bug

//移动匹配法
class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        string t=s+s;//拼接字符串
        t.erase(t.begin());
        t.erase(t.end()-1);//掐头去尾
        if(t.find(s)!=std::string::npos) return true;//找到字符串s
        return false;//未找到
        
    }
};

//KMP算法
class Solution {
public:
    //求前缀表
    void getNext(int *next,const string &s){
        int j=0;
        next[0]=0;//初始化

        for(int i=1;i<s.size();i++){//注意i=1
            while(j>0&&s[i]!=s[j]){//不匹配，回退
                j=next[j-1];
            }

            if(s[i]==s[j]) {
                j++;//匹配，更新j
            }

            next[i]=j;//更新前缀表
        }

    }

    bool repeatedSubstringPattern(string s) {
        if(s.size()==0){
            return false;//空字符串
        }

        int next[s.size()];//前缀表
        getNext(next,s);//！！！调用函数

        int len=s.size();
        if(next[len-1]!=0 && len%(len-next[len-1])==0){//根据结论
            return true;
        }

        else return false;
    }
};

学习总结

空字符串的返回

代码随想录

说明: 当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

关于KMP算法的理解及next数组的求法：

求next数组（前缀表）的思路其实也是KMP算法，利用的同样是“不匹配就回退”的思想
回退的位置是根据前缀表来决定的，前缀表描述的就是模式串的“对称程度”
KMP算法是利用字符串的“对称性”来减少匹配次数，改进计算复杂度自己总结的

关于指针回溯求next的理解每次求next【i】，可看作前缀与后缀的一次匹配，在该过程中就可以用上之前所求的next，若匹配失败，则像模式串与父串匹配一样，将指针移到next【j-1】上。求next过程实际上是dp（动态规划），只与前一个状态有关：若不匹配，一直往前退到0或匹配为止若匹配，则将之前的结果传递：因为之前的结果不为0时，前后缀有相等的部分，所以j所指的实际是与当前值相等的前缀，可视为将前缀从前面拖了过来，就不必将指针从前缀开始匹配了，所以之前的结果是可以传递的。

来自评论区帮你把KMP算法学个通透！（求next数组代码篇）_哔哩哔哩_bilibili