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;
}
};
细节处理
当一个字符串s:abcabc,内部由重复的子串组成,那么这个字符串的结构一定是这样的:
也就是由前后相同的子串组成。
那么既然前面有相同的子串,后面有相同的子串,用 s + s,这样组成的字符串中,后面的子串做前串,前后的子串做后串,就一定还能组成一个s,如图:
所以判断字符串s是否由重复子串组成,只要两个s拼接在一起,里面还出现一个s的话,就说明是由重复子串组成。
当然,我们在判断 s + s 拼接的字符串里是否出现一个s的的时候,要刨除 s + s 的首字符和尾字符,这样避免在s+s中搜索出原来的s,我们要搜索的是中间拼接出来的s。
string::npos作为string的成员函数的一个长度参数时,表示“直到字符串结束(until the end of the string)。所以if (t.find(s) != std::string::npos)表示在字符串结束前能够找到s。
直接用contains,find 之类的库函数。 却忽略了实现这些函数的时间复杂度(暴力解法是m * n,一般库函数实现为 O(m + n))。