leetcode 28.实现strStr()、459.重复的子字符串

最新推荐文章于 2024-02-01 17:10:31 发布

clementines_

最新推荐文章于 2024-02-01 17:10:31 发布

阅读量164

点赞数

文章标签： c++ leetcode 数据结构 Powered by 金山文档

本文链接：https://blog.csdn.net/qq_52097561/article/details/128745520

版权

文章详细介绍了如何使用KMP算法解决LeetCode的28题（实现strStr()）和459题（重复的子字符串）。在strStr()问题中，通过构建前缀表找到子串在主串中的位置。在重复子字符串问题中，利用KMP算法寻找最长相等前后缀，判断字符串是否由重复子串组成。时间复杂度均为O(m+n)，空间复杂度为O(n)。

摘要由CSDN通过智能技术生成

leetcode 28.实现strStr()

leetcode 459.重复的子字符串

对于KMP算法不了解可以看我前面的博客

leetcode 28.实现strStr()

代码实现

class Solution {
public:
    void getNext(int* next, const string& s) {
        int j = 0;
        next[0] = 0;
        for(int i = 1; i < s.size(); i++) {
            while (j > 0 && s[i] != s[j]) {
                j = next[j - 1];
            }
            if (s[i] == s[j]) {
                j++;
            }
            next[i] = j;
        }
    }
    int strStr(string haystack, string needle) {
        if (needle.size() == 0) {
            return 0;
        }
        int next[needle.size()];
        getNext(next, 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() ) {
                return i - needle.size() + 1;
            }
        }
        return -1;
    }
};

时间复杂度O(m+n)

空间复杂度O(m)

细节处理

只要理解了KMP算法的话，整体思路不难。需要注意的细节是在最后返回值时，由于返回值的最后一步一定是haystack[i] == needle[j]，这时给j++了，但是i++还要等到下一个循环，由于满足要求了所以退出循环，返回值要给i多加上1.

时间复杂度分析：n是字符串haystack的长度，m是字符串needle的长度。我们至多需要遍历两字符串一次。

空间复杂度分析：m是字符串needle的长度。我们只需要保存字符串needle的前缀表。

leetcode 459.重复的子字符串

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++){
            while(j > 0 && s[i] != s[j])
                j = next[j - 1];
            if(s[i] == s[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;
        }
        return false;
    }
};

时间复杂度O(n)

空间复杂度O(n)

细节处理

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

图中红框为最小重复字串。为什么是这样呢？

步骤一：因为这是相等的前缀和后缀，t[0] 与 k[0]相同， t[1] 与 k[1]相同，所以 s[0] 一定和 s[2]相同，s[1] 一定和 s[3]相同，即：，s[0]s[1]与s[2]s[3]相同。

步骤二：因为在同一个字符串位置，所以 t[2] 与 k[0]相同，t[3] 与 k[1]相同。

步骤三：因为这是相等的前缀和后缀，t[2] 与 k[2]相同，t[3]与k[3] 相同，所以，s[2]一定和s[4]相同，s[3]一定和s[5]相同，即：s[2]s[3] 与 s[4]s[5]相同。

步骤四：循环往复。

所以字符串s，s[0]s[1]与s[2]s[3]相同， s[2]s[3] 与 s[4]s[5]相同，s[4]s[5] 与 s[6]s[7] 相同。

正是因为最长相等前后缀的规则，当一个字符串由重复子串组成的，最长相等前后缀不包含的子串就是最小重复子串。

假设字符串s使用多个重复子串构成（这个子串是最小重复单位），重复出现的子字符串长度是x，所以s是由n * x组成。因为字符串s的最长相同前后缀的长度一定是不包含s本身，所以最长相同前后缀长度必然是m * x，而且 n - m = 1，（这里如果不懂，看上面的推理）所以如果 nx % (n - m)x = 0，就可以判定有重复出现的子字符串。这与代码中len % (len - (next[len - 1])) == 0所对应。

时间复杂度分析：n为字符串长度，遍历字符串。

空间复杂度分析：n为字符串长度，建立一个next数组长度为n。

移动匹配

代码实现

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; // r
        return false;
    }
};

细节处理