算法训练营 第九天

算法训练营 第九天

字符串day02~
开屏暴击一来就是kmp算法，上次刷题半道崩殂就是因为kmp，这次写，自己想还是想不出来捏。

28. 实现 strStr()

kmp算法的算法实现，步骤是：
1、构造next数组
a.初始化数组和i,j，其中i表示后缀末尾，j表示前缀末尾，同时j也是next数组要存储的数。
b.前后缀不相同时，要怎么处理，这里注意用while
c.前后缀相同的时候，要怎么处理，这里用的是if，因为每次循环，j已经保存了之前相同的前后缀个数，如果这次循环再相同就++即可。（可以举个例子自己尝试一下就明白了）
2、根据next数组遍历搜索子串
也设立两个指针，指针j指向needle，指针i指向haystack
1、如果两个指针指向的值相同，则两个指针都++,
2、如果两个指针指向的值不相同，则j往前倒，返回到next[j-1]，直到j==0.
3、停止条件：如果i到字符串末尾或者j到字符串末尾了就停止
循环完后，如果是j到末尾停止的，说明找到了相同字串，返回i-needle.size()；如果j还没到末尾呢，说明没找到相同字串，返回-1。
我的答案：

class Solution {
public:
    void getNext(vector<int>& next, string needle) {
        int j = 0;
        next[0] = 0;
        for (int i = 1; i < needle.size(); i++) {
            while (j > 0 && needle[i] != needle[j]) {
                j = next[j - 1];
            }
            if (needle[i] == needle[j]) {
                j++;
            }
            next[i] = j;

        }
    }
    int strStr(string haystack, string needle) {
        //先构建前缀表
        int len = needle.size();
        vector<int> next(len,-1);
        getNext(next, needle);
        //遍历hay，找相同子串
        int i = 0;
        int j = 0;
        for (; i < haystack.size()&&j<needle.size(); i++) {
            
            while (j > 0&&needle[j] != haystack[i] ) {
                j = next[j - 1];
            }
            if (needle[j] == haystack[i])
                j++; 
        }
        if (j == needle.size()) {
            return i - len;
        }
        return -1;

    }
};

代码随想录（参考答案）

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

459. 重复的子字符串

题目：

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

示例 1:
输入: s = “abab”
输出: true
解释: 可由子串 “ab” 重复两次构成。

示例 2:
输入: s = “aba”
输出: false

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

==========================分割线 ======================

这道题我的思路是，如果它可由重复的子串组成，那这个子串的大小一定是原字符串的1/2或1/4等，根据这个思路得到下面的步骤
1、首先判断字符串是否为偶数，不是偶数直接return false
2、先提取前一半的子串，判断两个子串叠加能否得到原字符串
3、如果不能则一直提取原字符串一半的一半，直到不能整除为止。
这种方法可以做，但和kmp算法就没有关系了，因此看看用kmp怎么做这道题。
看完答案发现两种方法都挺妙的
方法一：如果字符串s能由重复的子串构成，那么s+s组成的字符串掐头去尾以后，中间一定能够找到子串s。
解法：

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

很妙的写法，主要是思路很难想到，代码实现倒是不难。
第二种方法就是kmp算法，但也主要难在思路。字符串s的最长相等前后缀的长度，剩下的部分，就是可能的重复子串。
解法：

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        
        int j = 0;
        vector<int> next(s.size(), 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;
        }
        if (next[s.size()-1]!=0&&s.size() % (s.size() - next[s.size() - 1]) == 0)
            return true;
        return false;
        
    }
};

这两道题都挺难的，主要是得深入理解题目，希望下次三刷的时候能自己写出来。