4.10练习

目录

leetcode28:找出字符串中第一个匹配值的下标

题目：

示例：

解题思路：

代码实现：

leetcode459：重复的子字符串

题目：

示例：

解题思路：

代码实现：

---

leetcode28:找出字符串中第一个匹配值的下标

题目：

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。

示例：

示例 1：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

示例 2：

输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。

提示：

• 1 <= haystack.length, needle.length <= 104
• haystack 和 needle 仅由小写英文字符组成

解题思路：

KMP算法

记字符串 haystack的长度为 nnn，字符串 needle 的长度为 m。

我们记字符串 str=needle+#+haystack，即将字符串 needle 和 haystack 进行拼接，并用不存在于两串中的特殊字符 # 将两串隔开，然后我们对字符串 str求前缀函数。

因为特殊字符 # 的存在，字符串 str中 haystack部分的前缀函数所对应的真前缀必定落在字符串 needle部分，真后缀必定落在字符串 haystack 部分。当 haystack部分的前缀函数值为 m 时，我们就找到了一次字符串 needle在字符串 haystack 中的出现（因为此时真前缀恰为字符串 needle）。

实现时，我们可以进行一定的优化，包括：

我们无需显式地创建字符串 str。
为了节约空间，我们只需要顺次遍历字符串 needle、特殊字符 #和字符串 haystack 即可。
也无需显式地保存所有前缀函数的结果，而只需要保存字符串 needle 部分的前缀函数即可。
特殊字符 #的前缀函数必定为 0，且易知 π(i)≤m（真前缀不可能包含特殊字符 #）。
这样我们计算 π(i) 时，j=π(π(π(…)−1)−1)的所有的取值中仅有 π(i−1) 的下标可能大于等于 m。我们只需要保存前一个位置的前缀函数，其它的 j 的取值将全部为字符串 needle 部分的前缀函数。
我们也无需特别处理特殊字符 #，只需要注意处理字符串 haystack 的第一个位置对应的前缀函数时，直接设定 j的初值为 0 即可。

代码实现：

int strStr(char* haystack, char* needle) {
    int n = strlen(haystack), m = strlen(needle);
    if (m == 0) {
        return 0;
    }
    int pi[m];
    pi[0] = 0;
    for (int i = 1, j = 0; i < m; i++) {
        while (j > 0 && needle[i] != needle[j]) {
            j = pi[j - 1];
        }
        if (needle[i] == needle[j]) {
            j++;
        }
        pi[i] = j;
    }
    for (int i = 0, j = 0; i < n; i++) {
        while (j > 0 && haystack[i] != needle[j]) {
            j = pi[j - 1];
        }
        if (haystack[i] == needle[j]) {
            j++;
        }
        if (j == m) {
            return i - m + 1;
        }
    }
    return -1;
}

leetcode459：重复的子字符串

题目：

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

示例：

示例 1:

输入: s = "abab"
输出: true
解释: 可由子串 "ab" 重复两次构成。

示例 2:

输入: s = "aba"
输出: false

示例 3:

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

提示：

• 1 <= s.length <= 104
• s 由小写英文字母组成

解题思路：

枚举

如果一个长度为 n 的字符串 s 可以由它的一个长度为 n′  的子串 s 重复多次构成，那么：n 一定是 n′ 的倍数；s′  一定是 s 的前缀；对于任意的 i∈[n′,n)，有 s[i]=s[i−n′ ]。也就是说，s中长度为 n ′
  的前缀就是 s′ ，并且在这之后的每一个位置上的字符 s[i]，都需要与它之前的第 n′ 个字符 s[i−n′] 相同。

因此，我们可以从小到大枚举 n′，并对字符串 s 进行遍历，进行上述的判断。注意到一个小优化是，因为子串至少需要重复一次，所以 n′ 不会大于 n 的一半，我们只需要在 [1,n2]的范围内枚举 n′ 即可。

代码实现：

bool repeatedSubstringPattern(char* s) {
    int n = strlen(s);
    for (int i = 1; i * 2 <= n; ++i) {
        if (n % i == 0) {
            bool match = true;
            for (int j = i; j < n; ++j) {
                if (s[j] != s[j - i]) {
                    match = false;
                    break;
                }
            }
            if (match) {
                return true;
            }
        }
    }
    return false;
}