【代码随想录37期】Day09 实现strStr、重复的子字符串

实现strStr

代码随想录

28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）

28. 找出字符串中第一个匹配项的下标
原始版本：
//todo：1，检查
class Solution {
public:
    int strStr(string haystack, string needle) {
        if (needle.empty()) return 0;
        if(needle.size()> haystack.size()) return -1;
        for (int i = 0; i <= haystack.size() - needle.size(); i++) {
            int j = 0;
            while (j < needle.size() && haystack[i + j] == needle[j]) {
                j++;
            }
            if (j == needle.size()) {
                return i;
            }
        }
        return -1;
    }
};

v2.0:
使用KMP算法，KMP的看家本领是找出一个串里是否有指定的子串
核心工具就是前缀表prefix table，相当于一个存档，当不满足条件时，尽量利用已有的信息。
前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，再重新匹配，
此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。
关于最长相等前后缀：字符串a的最长相等前后缀为0。 字符串aa的最长相等前后缀为1。 字符串aaa的最长相等前后缀为2。 等等.....。
注意前缀不包含最后一个字符，后缀不包含第一个字符
吭哧吭哧写了半天，发现主要是没理解next数组的构建  可以多写几次，避免挫败感
class Solution {
public:
    vector<int> getNext(string s){
        vector<int> prefixTable(s.size(), 0);//其实可以不用这么搞，直接传进来一个数组就行，不用构造局部变量
        prefixTable[0] = 0;//前缀表开始就是0
        int j = 0;//j负责计算最长前后缀，其实前缀一定是从下标0开始的
        for(int i = 1; i <s.size(); i++){
            while(j>0 && s[i]!=s[j]){//当j没回退到最开始的0，而且又确实不相等时，就回退
               j = prefixTable[j-1];//j回退 
           }
           //当j回退到0或者有相等出现时，j累加
           if(s[i]==s[j]){//
               j++;
           }
           //一轮判断结束（相等或不相等，因为不相等会产生迭代，所以应该先判断不相等），更新前缀表
           prefixTable[i] = j;
           

        }
        return prefixTable;
    }
    int strStr(string haystack, string needle) {
        vector<int> prefixTable = getNext(needle);//拿到子串的前缀表
        int j = 0;
        for(int i = 0; i < haystack.size();i++){
            //其实跟构建前缀表的思想很像，也是先看当j没回退到最开始的0，而且又确实不相等时，就回退
           while(j>0 &&haystack[i]!=needle[j]){
               j = prefixTable[j - 1];
           }
           //当j回退到0或者有相等出现时，j累加
           if(haystack[i]==needle[j]){
               j++;
           }
           //如果到了字串末尾说明匹配成功了，返回下标（可以验算一下）
           if(j==needle.size()){
               return i - needle.size() + 1;
           }
        }
        return -1;//原串比对完了说明没有，返回-1

    }
};

v3.0：
1. 优化获得子串的函数
2. 避免特殊情况：字串为空返回0；
3. 避免重复计算：将needle.size()提前计算，并在循环中使用它的值，而不是每次都重新计算。

class Solution {
public:
    void getNext(string s, vector<int> &prefixTable){
        prefixTable[0] = 0;
        int j = 0;//j负责计算最长前后缀
        for(int i = 1; i <s.size(); i++){
            while(j>0 && s[i]!=s[j]){
               j = prefixTable[j-1];//j回退 
           }
           if(s[i]==s[j]){
               j++;
           }
           prefixTable[i] = j;
        }
    }
    int strStr(string haystack, string needle) {
        int n = needle.size();
        if(n==0)return 0;
        vector<int> prefixTable(n,0);
        getNext(needle, prefixTable);
        int j = 0;
        for(int i = 0; i < haystack.size();i++){
           while(j>0 &&haystack[i]!=needle[j]){
               j = prefixTable[j - 1];
           }
           if(haystack[i]==needle[j]){
               j++;
           }
           if(j==n){
               return i - n + 1;
           }
        }
        return -1;

    }
};

用这张图作为当前情况，

• 下一个字符依然相同时，很显然前缀长度+1，next[i] = j,j既可以计算前缀长度又是作为当前前缀下标

• 下一个字符不相同时，我们已经知道的是当前i指向位置和j指向位置之前是相同的，所以现在想要知道i指向位置之前这个子串ABA跟j指向位置之前这个子串ABA的最大共同前后缀，这样前面子串的前缀（ABA前面的A）和后面子串的后缀(ABA后面的A)又可以重新开始匹配，至于怎么获得ABA的最长公共前后缀，只需要读取j前面位置的前缀表即可

重复的子字符串

代码随想录

459. 重复的子字符串 - 力扣（LeetCode）

暴力方法：一个一个试不同长度的子串

感觉暴力也挺巧妙的，子串反正都是从头开始，所以第一个循环找子串的落点，循环条件因为i从1开始并且子串肯定在原串一半长度以下。

然后因为字串的长度需要满足能被原串整除，所以可以减少一部分遍历，在这里对于每种子串情况定义一个match，从落点开始（本来应该是i+1，但是i是从1开始的，所以j=i）到原串末尾，如果有不匹配的情况就跳出循环并且将match置为false，如果没有跳出过循环，说明出现了满足情况的子串，如果外层循环都结束了说明不满足情况。

v1.0：

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        for(int i = 1;i<=s.size()/2;i++){
            if(s.size()%i==0){
                bool match = true;
                for(int j = i;j<s.size();j++){
                    if(s[j-i]!=s[j]){
                        match =  false;
                        break;
                    }
                }
                if(match){
                    return true;
                    }

            }
            
        }
        return false;

    }
};
v2.0:比较巧妙的方法，由子串构成说明要么是ABAB,要么是ABABAB，此时会发现，由于原始串可以由子串重复构成，
当多个原始串拼起来时，前面有相同的子串，后面有相同的子串，后面的子串做前串，前面的子串做后串，
就一定还能组成一个原始串
class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        string ss = s+s;
        ss.erase(ss.begin());
        ss.erase(ss.end()-1);
        if(ss.find(s)!=string::npos)
        {
            return true;
        }
        return false;
    }
};

使用C++17:contains
class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        string ss = s+s;
        ss.erase(ss.begin());
        ss.erase(ss.end()-1);
        if(contains(ss,s))
        {
            return true;
        }
        return false;
    }
};

v3.0：使用KMP代替.find寻找子串
class Solution {
public:
    void getNext(string s, vector<int> &next)
    {
        int j = 0;//计算公共前后缀
        for(int i = 1; i< s.size();i++)
        {
            while(j>0&&s[j]!=s[i])
            {
                j = next[j-1];
            }
            if(s[j]==s[i])
            {
                j++;
            }
            next[i] = j;
        }
    }

    bool repeatedSubstringPattern(string s) {
        int n = s.size();
        if(n==0)return false;
        vector<int> next(n,0);
        getNext(s, next);
        string ss = s+s;
        ss.erase(ss.begin());
        ss.erase(ss.end()-1);
        for(int i = 0, j = 0; i< ss.size(); i++)
        {
            while(j>0&&s[j]!=ss[i])
            {
                j = next[j-1];
            }
            if(s[j]==ss[i])
            {
                j++;
            }
            if(j==n)
            {
                return true;
            }
        }
        return false;

    }
};

v4.0:唐，有了前缀表，是不是可以利用前缀表看看子串？
好确实有点不好理解，当我们有了next数组，因为最长公共前后缀必然不会包含原串
所以对于满足题意的原串，一定是n*sub_str最长公共前后缀必然为(n-1)*sub_str
所以如果有最小子串，设原串长度是L,则一定有L可以整除子串的长度L - next[L-1]
这里next[L-1]就是原串的最大公共前后缀
class Solution {
public:
    void getNext(string s, vector<int> &next)
    {
        int j = 0;//计算公共前后缀
        for(int i = 1; i< s.size();i++)
        {
            while(j>0&&s[j]!=s[i])
            {
                j = next[j-1];
            }
            if(s[j]==s[i])
            {
                j++;
            }
            next[i] = j;
        }
    }

    bool repeatedSubstringPattern(string s) {
        int n = s.size();
        if(n==0)return false;
        vector<int> next(n,0);
        getNext(s, next);
        if(next[n-1] > 0 && n % (n - next[n-1]) == 0)
        {
            return true;
        }
        return false;

    }
};