【刷题day9】字符串|28. 找出字符串中第一个匹配项的下标、459. 重复的子字符串

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

朴素解法：枚举原串中的每个字符作为「发起点」每次从原串的「发起点」和匹配串的「首位」开始尝试匹配：匹配成功：返回本次匹配的原串「发起点」。匹配失败：枚举原串的下一个「发起点」，重新尝试匹配。

int strStr(string haystack, string needle) {
        int n = haystack.size(), m = needle.size();
        for(int i = 0; i <= n - m; i++){
            int j = i;//原串中寻找子串的遍历指针
            int k = 0; //子串的遍历指针
            while(k < m and haystack[j] == needle[k]){
                j++;
                k++;
            }
            if(k == m) 
                return i;//返回起始位置
        }
        return -1;
    }

KMP

KMP 算法可以快速在「原字符串」中找到「匹配字符串」。首先在「原串」和「匹配串」分别各自有一个指针指向当前匹配的位置，如果匹配，两个指针会同时往右移动，直到出现第一个不同的位置。如果使用朴素算法匹配，发现不匹配，此时就要从头匹配了。但如果使用前缀表，不会从头匹配，而是从上次已经匹配的内容开始匹配。next数组就是一个前缀表,前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，在重新匹配，此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。前缀表记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。前缀表具有告诉我们当前位置匹配失败，跳到之前已经匹配过的地方的能力。

void getNext(int* next, const string& s) {
        int j = 0;
        next[0] = 0;
        for(int i = 1; i < s.size(); i++) {//从1开始
            while (j > 0 && s[i] != s[j]) {//遇到前后缀末尾不相同的情况，就要向前回溯
                j = next[j - 1];// 向前回溯
            }
            if (s[i] == s[j]) {// 找到相同的前后缀
                j++;
            }
            next[i] = j;//将j（前缀的长度）赋给next[i], 因为next[i]要记录相同前后缀的长度。
        }
    }
    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++) {//从0开始
            while(j > 0 && haystack[i] != needle[j]) {//如果不匹配，j从next数组里寻找下一个匹配位置
                j = next[j - 1];
            }
            if (haystack[i] == needle[j]) {//如果匹配，那么i 和 j 同时向后移动
                j++;
            }
            if (j == needle.size() ) {//如果j指向了子串t的末尾，那么模式串t完全匹配文本串s里的某个子串
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }

459. 重复的子字符串

当一个字符串内部由重复的子串组成，那么这个字符串一定由前后相同的子串组成。那么既然前面后面都有相同的子串，这样组成的字符串中，后面的子串做前串，前面的子串做后串，就一定还能组成一个s，所以判断字符串s是否有重复子串组成，只要两个s拼接在一起，里面还出现一个s的话，就说明是由重复子串组成。当然，我们在判断拼接的字符串里是否出现一个s的的时候，要刨除 s + s 的首字符和尾字符，这样避免在s+s中搜索出原来的s，我们要搜索的是中间拼接出来的s。

在C语言中，字符串存储为字符数组，以'\0'结束。 在C的接口中，有strstr函数，可以在字符串中查找另一个字符串。char * strstr(const char *str1, const char *str2);功能为在str1中查找str2,如果存在，那么返回查找到的起始指针，否则返回NULL。

C++的string类提供了字符串中查找另一个字符串的函数find。string::size_type string::find(string &);功能为在string对象中，查找参数string类型的字符串是否存在，如果存在，返回起始位置。不存在则返回 string::npos。

 bool repeatedSubstringPattern(string s) {
        string t = s + s;
        t.erase(t.begin()); t.erase(t.end() - 1); // 掐头去尾
        if (t.find(s) != std::string::npos) 
//std::string::npos等于size_type类型可以表示的最大值，用来表示一个不存在的位置
            return true; // r
        return false;

    }

最小重复子串就是他的最长相等前后缀不包含的那一部分
next[len - 1]是最长相等前后缀的长度
len - (next[len - 1]))即最小重复子串，就是他的最长相等前后缀不包含的那一部分
len % (len - (next[len - 1])) == 0能被原字符串长度整除的话 说明整个字符串是由重复子串组成的

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]) {//前后缀不相同的情况 因为是连续回退--while
                j = next[j - 1];
            }
            if(s[i] == s[j]) {//前后缀相同的情况
                j++;
            }
            next[i] = j;//更新next数组
        }
    }
    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;
    }