【Day5】字符串与字符串匹配

03.02.08 练习题目（第 05 天）

1. 0796. 旋转字符串

1.1 题目大意

描述：给定两个字符串 s 和 goal。

要求：如果 s 在若干次旋转之后，能变为 goal，则返回 True，否则返回 False。

说明：

• s 的旋转操作：将 s 最左侧的字符移动到最右边。
  • 比如：s = "abcde"，在旋转一次之后结果就是 s = "bcdea"。
• $1\le s.length,goal.length\le 100$。
• s 和 goal 由小写英文字母组成。

示例：

输入: s = "abcde", goal = "cdeab"
输出: true


输入: s = "abcde", goal = "abced"
输出: false

我的答案：

/*
方法一：暴力旋转

1. 遍历 `s` 的每一个可能的旋转结果。
2. 每次旋转后，检查旋转结果是否等于 `goal`。
3. 如果找到一个旋转结果等于 `goal`，返回 `true`。
4. 如果遍历完所有可能的旋转结果都没有找到，返回 `false`。
*/
class Solution {
public:
    bool rotateString(string s, string goal) {
        if (s.length() != goal.length()) return false;
        int n = s.length();
        for (int i = 0; i < n; ++i) {
            if (s == goal) return true;
            s = s.substr(1) + s[0];
        }
        return false;
    }
};
//方法二：字符串拼接
/*
1. 如果 s 和 goal 长度不同，直接返回 false。
2. 将 s 自身拼接一次，形成新的字符串 s + s。
3. 检查 goal 是否是 s + s 的子字符串。
4. 如果是，返回 true；否则，返回 false。
*/
class Solution {
public:
    bool rotateString(string s, string goal) {
        if (s.length() != goal.length()) return false;
        return (s + s).find(goal) != string::npos;
    }
};

心得：

1. 暴力旋转方法虽然直观，但时间复杂度较高，为 O(n^2)，其中 n 是字符串的长度。因为每次旋转操作都需要 O(n) 的时间，而最多需要旋转 n 次。

2. 字符串拼接方法利用了字符串拼接和子字符串查找的特性，时间复杂度为 O(n)，其中 n 是字符串的长度。这种方法更高效，因为它只需要一次拼接操作和一次子字符串查找操作。

2. 1408. 数组中的字符串匹配

2.1 题目大意

描述：给定一个字符串数组 words，数组中的每个字符串都可以看作是一个单词。如果可以删除 words[j] 最左侧和最右侧的若干字符得到 word[i]，那么字符串 words[i] 就是 words[j] 的一个子字符串。

要求：按任意顺序返回 words 中是其他单词的子字符串的所有单词。

说明：

• $1\le words.length\le 100$。
• $1\le words[i].length\le 30$
• words[i] 仅包含小写英文字母。
• 题目数据保证每个 words[i] 都是独一无二的。

示例：

输入：words = ["mass","as","hero","superhero"]
输出：["as","hero"]
解释："as" 是 "mass" 的子字符串，"hero" 是 "superhero" 的子字符串。此外，["hero","as"] 也是有效的答案。

我的答案：

class Solution {
public:
    vector<string> stringMatching(vector<string>& words) {
        vector<string> result;
        for (int i = 0; i < words.size(); ++i) {
            for (int j = 0; j < words.size(); ++j) {
                if (i != j && words[j].find(words[i]) != string::npos) {
                    result.push_back(words[i]);
                    break;
                }
            }
        }
        return result;
    }
};

3. 2156. 查找给定哈希值的子串

3.1 题目大意

描述：如果给定整数 p 和 m，一个长度为 k 且下标从 0 开始的字符串 s 的哈希值按照如下函数计算：

• $hash(s,p,m)=(val(s[0])\ast p^0+val(s[1])\ast p^1+...+val(s[k-1])\ast p^{k-1})modm$.

其中 val(s[i]) 表示 s[i] 在字母表中的下标，从 val('a') = 1 到 val('z') = 26。

现在给定一个字符串 s 和整数 power，modulo，k 和 hashValue 。

要求：返回 s 中 第一个 长度为 k 的 子串 sub，满足 hash(sub, power, modulo) == hashValue。

说明：

• 子串：定义为一个字符串中连续非空字符组成的序列。
• $1\le k\le s.length\le 2\ast 10^4$。
• $1\le power,modulo\le 10^9$。
• $0\le hashValue<modulo$。
• s 只包含小写英文字母。
• 测试数据保证一定存在满足条件的子串。

示例：

输入：s = "leetcode", power = 7, modulo = 20, k = 2, hashValue = 0
输出："ee"
解释："ee" 的哈希值为 hash("ee", 7, 20) = (5 * 1 + 5 * 7) mod 20 = 40 mod 20 = 0 。
"ee" 是长度为 2 的第一个哈希值为 0 的子串，所以我们返回 "ee" 。

答案：

class Solution {
public:
    string subStrHash(string s, int power, int mod, int k, int hashValue) {
        int n = s.length();
        // 用秦九韶算法计算 s[n-k:] 的哈希值，同时计算 pk=power^k
        long long hash = 0, pk = 1;
        for (int i = n - 1; i >= n - k; i--) {
            hash = (hash * power + (s[i] & 31)) % mod;
            pk = pk * power % mod;
        }
        int ans = hash == hashValue ? n - k : 0;
        // 向左滑窗
        for (int i = n - k - 1; i >= 0; i--) {
            // 计算新的哈希值，注意 +mod 防止计算出负数
            hash = (hash * power + (s[i] & 31) - pk * (s[i + k] & 31) % mod + mod) % mod;
            if (hash == hashValue) {
                ans = i;
            }
        }
        return s.substr(ans, k);
    }
};

// 作者：灵茶山艾府
// 链接：https://leetcode.cn/problems/find-substring-with-given-hash-value/solutions/1239542/dao-xu-hua-dong-chuang-kou-o1-kong-jian-xpgkp/
// 来源：力扣（LeetCode）
// 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。