力扣-187. 重复的DNA序列
1.题目
题目地址(187. 重复的DNA序列 - 力扣（LeetCode）)
https://leetcode.cn/problems/repeated-dna-sequences/
题目描述
DNA序列 由一系列核苷酸组成，缩写为 'A', 'C', 'G' 和 'T'.。
- 例如，
"ACGAATTCCG"是一个 DNA序列 。
在研究 DNA 时，识别 DNA 中的重复序列非常有用。
给定一个表示 DNA序列 的字符串 s ，返回所有在 DNA 分子中出现不止一次的 长度为 10 的序列(子字符串)。你可以按 任意顺序 返回答案。
示例 1：
输入：s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT" 输出：["AAAAACCCCC","CCCCCAAAAA"]
示例 2：
输入：s = "AAAAAAAAAAAAA" 输出：["AAAAAAAAAA"]
提示：
0 <= s.length <= 105s[i]=='A'、'C'、'G'or'T'
2.题解
2.1 哈希表
思路
使用substr截取子串，使用哈希表计算出现次数，出现次数为两次的计数（超过的不重复计数）
代码
- 语言支持：C++
C++ Code:
class Solution {
const int L = 10;
public:
vector<string> findRepeatedDnaSequences(string s) {
vector<string> ans;
unordered_map<string, int> cnt;
int n = s.length();
for (int i = 0; i <= n - L; ++i) {
string sub = s.substr(i, L);
if (++cnt[sub] == 2) {
ans.push_back(sub);
}
}
return ans;
}
};
复杂度分析
令 n 为字符串长度，L为子串长度10。
- 时间复杂度：\(O(nL)\)， 由于使用 String 作为 Key 会重复计算散列值
- 空间复杂度：O(N)。
如果我们期望做到严格 ，进行计数的「哈希表」就不能是以 String 作为 key，
只能使用 Integer（也就是 hash 结果本身）作为 key。
因为 String 的 hashCode 实现是会对字符串进行遍历的，这样哈希计数过程仍与长度有关，
而 Integer 的 hashCode 就是该值本身，这是与长度无关的。
2.2 滑动窗口 + 位运算 + 哈希表
思路
由于每次进行substr操作，都需要O(L)的时间复杂度，
我们考虑使用滑动窗口 + 哈希表进行优化：
由于 L <= 10, 且只有可能出现四个字母 A C G T
我们考虑直接使用字符串处理的话，每次需要截取第一个字符，再添加后一个字符，反而操作更麻烦了
所以我们考虑将字符串操作改为位操作，将 A(00) C(01) G(10) T(11) 进行转换（位操作对于维护滑动窗口十分友好，只要通过简单的位移操作便能达到维护的效果）
则为一个字符占据两位bit，L<=10, 最多占据20位，int总共32位，完全足够！
我们具体的维护操作：
1.将窗口整体前移一个位置（也就是我们维护的int向左移动两个bit，一个字符占据两个bit！）
2.将新的字符加进来（使用或运算，填补到之前前移产生的空位上）
3.将老的字符去除，只保留后20位的值（使用与运算，& ((1 << 20) - 1) = & (01111111111...)）
不断重复，同时维护哈希表，找到重复出现两次以上的。
代码
class Solution {
const int L = 10;
unordered_map<char, int> bin{{'A', 0}, {'C', 1}, {'G', 2}, {'T', 3}};
public:
vector<string> findRepeatedDnaSequences(string s) {
vector<string> ans;
unordered_map<int, int> cnt;
int n = s.length();
// 初始化(最后一个放在下面一起处理，不要等号=)
int x = 0;
for(int i = 0; i < L - 1; i++){
x = (x << 2) | bin[s[i]];
}
// 处理长度为L的子串(或运算加上新的字符，与运算去除旧的第一个字符，实现滑动窗口)
for (int i = L - 1; i < n; ++i) {
x = ((x << 2) | bin[s[i]]) & ((1 << 20) - 1);
if (++cnt[x] == 2) {
ans.push_back(s.substr(i - L + 1, L));
}
}
return ans;
}
};
复杂度分析
令 n 为字符串长度，L为子串长度10。
- 时间复杂度：O(N)，其中 N 是字符串 s 的长度。
- 空间复杂度：O(N)。
2.3 字符串哈希（滚动哈希）
思路
总体思路和2.2是一样的，但是2.2中的思路适用于字符数较少的情况，比如像这里只有4个字符，如果字符数较多就不好用位运算处理了
所以我们就不使用位运算，使用更为通用的滚动哈希算法（基础原理——前缀和）
滚动哈希算法的核心思想是通过预计算和利用前一个子串的哈希值来快速计算出下一个子串的哈希值。
这在子串比较中可以极大地提升效率，可以常数时间内计算出字符串的哈希值，
要想求出任意一段连续子串的hashCode，其想法类似于前缀和（这里的b为选择的基数，p为所选择的模数）
hash[r]与hash[l - 1]中间相差了一定长度的字符串，其长度为r - l + 1
所以通过求出pow(b, r - l + 1)，就可以求出从l到r的hashCode
hashCode(l, r) = hash[r] - hash[l - 1] * pow(b, r - l + 1)
但注意的是，还需要对p取模，并且由于是hashCode之间相减，得到的hashCode有可能是负数
所以hashCode(l, r) = ((hash[r] - hash[l - 1] * pow(b, r - l + 1)) % p + p) % p
因此一个能够做到严格 \(O(n)\) 的做法是使用「字符串哈希 + 前缀和」。
具体做法为，我们使用一个与字符串 s 等长的哈希数组 h[] ，以及次方数组 p[]。
由字符串预处理得到这样的哈希数组和次方数组复杂度为\(O(n)\)。
当我们需要计算子串s[i...j]的哈希值，只需要利用前缀和思想 h[j] - h[i-1] * p[j - i + 1]即可在 \(O(1)\) 时间内得出哈希值（与子串长度无关）。
代码
class Solution {
public:
vector<string> findRepeatedDnaSequences(string s) {
if (s.length() < 10) return {};
int P = 11111; // 基数
long long MOD = 1e9 + 7; // 模数
long long hash = 0, power = 1; // 哈希值， 位权
unordered_map<long long, int> seenHashes;
vector<string> result;
// 计算第一个长度为10的子串的哈希值
for (int i = 0; i < 10; ++i) {
hash = (hash * P + s[i]) % MOD; // 计算哈希值
power = (power * P) % MOD; // 求最高位的位权，不直接用pow是防止溢出
}
seenHashes[hash] = 1; // 使用哈希值作为键，出现次数作为值
// 滚动哈希计算其余子串的哈希值
for (int i = 10; i < s.length(); ++i) {
// 去除旧字符串第一位（需要乘以相应位权）加上新的一个字符放在最后 防止出现负数+MOD
hash = (hash * P + s[i] - s[i - 10] * power % MOD + MOD) % MOD;
if (seenHashes[hash] == 1) {
result.push_back(s.substr(i - 9, 10));
}
seenHashes[hash]++;
}
return result;
}
};
备注
- 字符串哈希的「构造 数组」和「计算哈希」的过程，不会溢出吗？
在Java中会溢出，溢出就会变为负数，
当且仅当两个哈希值溢出程度与 Integer.MAX_VALUE 呈不同的倍数关系时，会产生错误结果（哈希冲突），
此时考虑修改 P 或者采用表示范围更大的 long 来代替 int。
但是在C++中，我们选择使用模数求余来避免溢出的情况。
- 这个数字是怎么来的？
WA 出来的，刚开始使用的 131 ，被卡在了 30/31 个样例。
字符串哈希本身存在哈希冲突的可能，一般会在尝试 131 之后尝试使用 13131，然后再尝试使用比 13131 更大的质数。
但选择发现11111最好，直接通过。
