算法训练营Day9 第四章 字符串part2

第一部分：KMP算法总结与归纳

        KMP算法用于解决在一段较长的字符串中找出是否存在与另一个较短字符串相同的子串，举个例子：

有字符串haystack = "sadbutsad"和字符串needle = "sad"，我们找一下在前一个字符串中，是否存在与后一个字符串相同的子串，这时如果使用暴力解法，时间复杂度为两者大小之积，比较耗费时间，可以使用KMP算法来更好地求解这一问题。

        KMP算法的优势在于对于较长字符串haystack而言，遍历的过程中一直是从前向后的，不会出现往前移动重复查找的问题。KMP算法的关键在于要找到字符串needle子串（子串必须包含前缀，如：s, sa, sad这三个，其余子串不考虑）中相等的最长前后缀，并以此构建一个next(profix)数组，next数组中存放的内容可以理解成，当遍历过程中出现不相等时，下一次needle需要进行比较的位置下标。

        next数组的构建分为四个步骤：①初始化；②前后缀不相同时的处理过程；③前后缀相同时的处理过程；④修改next对应位置的值。

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

        这样，当我们有了next数组后，每次比较两个字符串时，当出现元素不匹配的时候，就让下一次比较needle的下标为next数组中对应的下标，这样极大的降低了算法的时间复杂度。

第一题： 28. 实现 strStr()

        这道题比较容易想到暴力解决法，也就是两层for循环遍历，但也可以使用KMP算法解决更好的解决，这是一道典型的使用KMP算法解决的题目，代码如下：

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;
        }
        int next[needle.size()];
        getNext(next, 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;
    }
};

        令haystack的长度为n，needle的长度为m，那么使用KMP算法的时间复杂度为O(n + m)，空间复杂度为O(m), 因为只需要保存字符串needle的前缀表。

 第二题： 459.重复的子字符串

        这道题同样是KMP算法的应用，需要更加熟练地掌握KMP算法！！！（KMP算法的题目要重复刷！！！）代码如下:

        

class Solution {
public:
    void getNext (int* next, const string& s){
        next[0] = 0;
        int j = 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).