LeetCode 30 串联所有单词的子串:一次 159/183 的 WA 复盘
一句话结论先放这儿:这题的核心不是"窗口",而是先把词边界对齐,再在每条对齐网格上独立滑窗。
这篇文章按我真实的思考顺序写:先有思路 → 写出第一版 → 被用例打脸 → 定位到一行代码 → 修复 → 换个角度把原理讲透 → 再做两轮优化。每一版代码都保留,方便你看到"坑"和"改进"的差别。
目录
- 1. 题目
- 2. 第一反应:暴力
- 3. 关键一步:按
起点 % len分组 - 4. 第一版代码(然后 WA 了)
- 5. 用题目用例把 bug 跑出来
- 6. 修复:把 hash2 移进循环
- 7. 换个角度理解 count
- 8. 改进一:加 count 守卫,别让垃圾块污染哈希表
- 9. 改进二:find 复用迭代器
- 10. 最终代码
- 11. 正确性:三个问题
- 12. 复杂度
- 13. 坑点清单
- 14. 横向对比
- 15. 还能复用到哪
- 16. 背下来的模板
- 17. 版本演进一览
1. 题目
给定字符串 s 和字符串数组 words,words 中所有字符串长度相同。
s 的「串联子串」是指:包含 words 中所有字符串、以任意顺序排列连接起来的子串。
返回所有串联子串在 s 中的起始下标,顺序任意。
示例 1
输入:s = "barfoothefoobarman", words = ["foo","bar"]
输出:[0,9]
示例 2
输入:s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
输出:[]
示例 3
输入:s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
输出:[6,9,12]
约束
| 项 | 范围 |
|---|---|
s.length | 1 ~ 10^4 |
words.length | 1 ~ 5000 |
words[i].length | 1 ~ 30 |
| 字符集 | 小写字母 |
所有 words[i] 长度相同 | 是 |
2. 第一反应:暴力
最直接的想法:
- 窗口总长度固定为
m * len(m = words.size(),len = words[0].size()); - 枚举每个起点
st; - 把窗口切成
m块,每块长len,统计词频,和words的词频比对。
复杂度:
起点数 O(n) × 块数 O(m) × 每块取子串/哈希 O(len) = O(n·m·len)
代入上限:10^4 × 5000 × 30 = 1.5 × 10^9,必然超时。
思考:暴力给了我们一个正确的"判定标准"——窗口内每个词的计数,必须和
words里该词的计数完全相等,不多不少。接下来要做的,只是把这个判定"滑"起来。
3. 关键一步:按 起点 % len 分组
3.1 为什么可以"跳着"枚举起点
任何一个合法的串联子串,它的第 k 个词一定从 起点 + k·len 开始。
也就是说,词与词的边界,被 len 完全固定死了。只要起点确定,整条"切块网格"就确定。
于是:
起点相差
len的两个窗口,中间的m-1块是同一批,只差一头一尾——这才有资格做滑动窗口。
起点相差 1 的两个窗口呢?切块完全错位,没法共享状态。
3.2 分组:把起点按余数分跑道
相位 0: [bar][foo][the][...] ← 起点 0, 3, 6, ...
相位 1: [arf][oot][he.][...] ← 起点 1, 4, 7, ...
相位 2: [rfo][oth][e..][...] ← 起点 2, 5, 8, ...
- 每个相位内部,块边界是同一套网格,可以在块序列上滑窗;
len个相位,恰好覆盖所有起点,不重不漏。
思考:注意例 1 的答案
9不是len的倍数,但它属于相位 0(9 % 3 == 0),只是相位 0 上的下一个窗口位置。所以"一个相位"不等于"一个答案",相位里还要继续滑。
3.3 组内怎么滑
窗口在字符上是 [left, right + len),在块上是"若干个连续块":
- 每轮
right += len,加入一个块; - 如果窗口块数超过
m,就left += len,弹出一个块; - 每轮检查"当前窗口是否恰好匹配";
- 用一张
hash2记录窗口内块的频次,用一个count记录"已满足的需求数"。
因为 right 和 left 每次都只动一个块,窗口最多超出一个块,所以收缩用 if 就够了,不需要 while。
4. 第一版代码(然后 WA 了)
思路看起来没问题,我写出了第一版:
class Solution {
public:
vector<int> findSubstring(string s, vector<string>& words) {
unordered_map<string, int> hash1;
for (auto &s: words) hash1[s]++;
unordered_map<string, int> hash2; // ← 问题就出在这一行
int len = words[0].size(), m = words.size();
vector<int> ret;
for (int i = 0; i < len; i++) {
for (int left = i, right = i, count = 0; right + len <= s.size(); right += len) {
string in = s.substr(right, len);
if (hash2[in]++ < hash1[in]) count++;
if (right - left + 1 > len * m) {
string out = s.substr(left, len);
left += len;
if (hash2[out]-- <= hash1[out]) count--;
}
if (count == m) ret.push_back(left);
}
}
return ret;
}
};
提交结果:
159 / 183 个通过的测试用例
反例:
输入:s = "aaaaaaaaaaaaaa", words = ["aa","aa"]
输出:[0,2,4,6,8,10]
预期:[0,1,2,3,4,5,6,7,8,9,10]
偶数全对,奇数全丢。 这个现象非常整齐,整齐到不像随机错误——一定是"某一整类起点"被系统性地漏掉了。
5. 用题目用例把 bug 跑出来
参数:len = 2,m = 2,窗口 4 个字符,hash1 = {aa: 2}。
5.1 相位 0(偶数起点)
hash2 是空的,一切正常:
| 步骤 | 加入块 | hash2[aa] | count | 窗口块数 | 动作 |
|---|---|---|---|---|---|
right=0 | aa | 0 → 1 | 1 | 1 | — |
right=2 | aa | 1 → 2 | 2 | 2 | 输出 left=0 |
right=4 | aa | 2 → 3 | 2 | 3 → 弹出 1 块 | 输出 left=2 |
right=6 | aa | 2 → 3 | 2 | 3 → 弹出 1 块 | 输出 left=4 |
right=8 | aa | 2 → 3 | 2 | 3 → 弹出 1 块 | 输出 left=6 |
right=10 | aa | 2 → 3 | 2 | 3 → 弹出 1 块 | 输出 left=8 |
right=12 | aa | 2 → 3 | 2 | 3 → 弹出 1 块 | 输出 left=10 |
相位 0 结束,输出 [0,2,4,6,8,10],而且 hash2 最后停在 {aa: 2}。
为什么?因为窗口始终保持 m 个块,相位跑完时窗口里恰好还剩 m 块,计数自然就等于 hash1。
5.2 相位 1(奇数起点)
相位 1 一进来,hash2 还是上一相位留下的 {aa: 2},而 hash1[aa] = 2:
if (hash2[in]++ < hash1[in]) count++; // 2 < 2 → false
| 步骤 | 加入块 | hash2[aa] | 判断 | count |
|---|---|---|---|---|
right=1 | aa | 2 → 3 | 2 < 2 假 | 0 |
right=3 | aa | 3 → 4 | 3 < 2 假 | 0 |
right=5 | aa | 4 → 5,随后弹出 → 4 | 假 | 0 |
| … | … | … | 永远为假 | 永远是 0 |
每次加词都被判定为"已经够了",count 一次都不涨,相位 1 一个答案都输出不了。相位 2 及之后同样被污染。
5.3 结论:根因是一行
hash2定义在for (int i = 0; i < len; i++)的外面。每个相位是独立的子问题,但账本被上一相位用过了,没换新的。
left / right / count 都在循环内重置了,只有 hash2 没有。
5.4 为什么这个 bug 只会漏解、不会多解
把"已满足的需求数"记作:
f(hash2) = Σ_w min(hash2[w], hash1[w])
相位开始时 count = 0,但 hash2 带着上次的残留,记此时的值为 f0。之后每加/删一个块,count 的增量和 f 的增量是完全一致的,所以任意时刻:
count = f(当前) - f0 ≤ m - f0
- 若
f0 > 0,count恒小于m,这个相位一个答案都不会输出(漏解); - 若
f0 = 0,这个相位才等价于"干净状态"。
所以这个 bug 只会漏,不会多。这也解释了为什么 159 个用例能过:很可能这批用例里 len = 1 的居多——只有一个相位,根本不存在"上一个相位";另外一些用例答案本身为空,漏了也看不出来。
6. 修复:把 hash2 移进循环
改动只有一行:
- unordered_map<string, int> hash2;
int len = words[0].size(), m = words.size();
vector<int> ret;
for (int i = 0; i < len; i++) {
+ unordered_map<string, int> hash2; // 每个相位独立账本
for (int left = i, right = i, count = 0; right + len <= s.size(); right += len) {
修复后:
class Solution {
public:
vector<int> findSubstring(string s, vector<string>& words) {
unordered_map<string, int> hash1;
for (auto &w : words) hash1[w]++;
int len = words[0].size(), m = words.size();
vector<int> ret;
for (int i = 0; i < len; i++) {
unordered_map<string, int> hash2; // 关键:每个相位重置
for (int left = i, right = i, count = 0; right + len <= s.size(); right += len) {
string in = s.substr(right, len);
if (hash2[in]++ < hash1[in]) count++;
if (right - left + 1 > len * m) {
string out = s.substr(left, len);
left += len;
if (hash2[out]-- <= hash1[out]) count--;
}
if (count == m) ret.push_back(left);
}
}
return ret;
}
};
再跑那个反例:相位 1 从空的 hash2 开始,1,3,5,7,9 全部输出,和相位 0 的 0,2,4,6,8,10 合起来正好是 0 ~ 10。
复盘:这种"分组/分治"的题,凡是跨组共享的状态,都要问一句"它该不该在组开始时清零"。
这题的组是"相位",共享状态是"窗口词频"。
7. 换个角度理解 count
修好之后,我想把 count 到底在数什么彻底想清楚,因为后面所有优化都建立在它上面。
7.1 count 是"多重集交集"的大小
把两边都看成多重集:
hash1[w]:需要w几次(需求)hash2[w]:窗口里现在有w几次(供给)
那么:
count = Σ_w min(hash2[w], hash1[w])
就是"把窗口里的块和需求清单做一一配对,最多能配上多少对"——也就是两个多重集的交集大小。
7.2 为什么不能直接数 Σ hash2
words = ["foo","bar","foo"],即 hash1 = {foo:2, bar:1},m = 3:
| 窗口内容 | hash2 | min 逐项 | count | 含义 |
|---|---|---|---|---|
foo foo foo | foo:3, bar:0 | min(3,2)=2,min(0,1)=0 | 2 | 多出来的 foo 没用 |
foo bar qux | foo:1, bar:1, qux:1 | 1 + 1 + 0 | 2 | 差一个 foo |
bar foo foo | foo:2, bar:1 | 2 + 1 | 3 | 恰好配齐 |
foo foo foo 的 Σ hash2 = 3,但只需要 2 个 foo,直接数会误判成"完成"。min 的作用就是每个词最多只算 hash1[w] 次,把多余的重复挡在外面。
7.3 加/删为什么用那两行就能维护
min(h2, h1) 对 h2 的斜率很特殊:h2 < h1 时每加 1 涨 1;h2 ≥ h1 时加多少都不涨。
| 操作 | 条件 | min 变化 | 代码 |
|---|---|---|---|
加入 w | h2[w] < h1[w](正缺) | +1 | if (h2[w]++ < h1[w]) count++ |
加入 w | h2[w] ≥ h1[w](已够) | 0 | 同上,条件不成立 |
弹出 w | h2[w] ≤ h1[w](弹出的是有用的) | −1 | if (h2[w]-- <= h1[w]) count-- |
弹出 w | h2[w] > h1[w](弹出的是多余的) | 0 | 同上,条件不成立 |
注意弹出判断用的是弹出前的旧值(h2[out]-- 是后置自减):h2 == h1 时算"有用",要减;h2 == h1 + 1 时说明这份是多余的,减完仍 ≥ h1,不减 count。
7.4 count == m 为什么就等价于"恰好匹配"
count = m = Σ hash1⇒ 每一项都取满 ⇒ 对所有w,h2[w] ≥ h1[w];- 所以窗口块数
Σ h2 ≥ Σ h1 = m; - 而窗口收缩条件保证块数
≤ m。
两边一夹:块数恰好 m,且总量相等、每个词都不缺 ⇒ h2 == hash1,一个不多一个不少。
所以"长度 == m·len"不是判定条件,它只负责决定什么时候弹出。count == m 本身已经蕴含了长度正确。
8. 改进一:加 count 守卫,别让垃圾块污染哈希表
修好重置问题之后,代码能 AC,但还有一个隐患:s 里大量块根本不在 words 中。
if (hash2[in]++ < hash1[in]) count++; // 未知块也会往 hash1、hash2 里各插一个键
unordered_map::operator[] 在键不存在时会插入默认值,于是:
hash2会膨胀到O(n)个不同的块键;hash1被s里的词不断污染,键越来越多,查找变慢;- 虽然不影响
count的正确性(min(k, 0) = 0),但纯属浪费内存和时间。
加一个守卫即可:
class Solution {
public:
vector<int> findSubstring(string s, vector<string>& words) {
unordered_map<string, int> hash1;
for (auto &s: words) hash1[s]++;
int len = words[0].size(), m = words.size();
vector<int> ret;
for (int i = 0; i < len; i++) {
unordered_map<string, int> hash2;
for (int left = i, right = i, count = 0; right + len <= s.size(); right += len) {
string in = s.substr(right, len);
if (hash1.count(in) && hash2[in]++ < hash1[in]) count++;
if (right - left + 1 > len * m) {
string out = s.substr(left, len);
left += len;
if (hash1.count(out) && hash2[out]-- <= hash1[out]) count--;
}
if (count == m) ret.push_back(left);
}
}
return ret;
}
};
两处都要加守卫,加入和弹出必须对称:未知块既然没被记录,弹出时也不能去减它。
这是自洽的:每个进入窗口的"已知词"一定被记录过,所以弹出时 hash2[out] ≥ 1,不会减成负数;未知块在两边都被跳过,不影响 count。
思考:这个守卫是"正确性不变、性能变好"的典型改动。写的时候要问自己:加入和弹出是否对称? 只加一边,必出负计数。
9. 改进二:find 复用迭代器
接下来是一个很容易被误解的点。
9.1 先纠正一个直觉
有人会问:find 和 count 时间复杂度不是一样吗?为什么说 find 更快?
单次调用确实一样:都是"对参数算一次哈希 O(len) + 走一次桶链(期望 O(1))"。
差别不在单次调用,而在整行调用了多少次:
| 整行代码 | 对 hash1 的调用 | 对 hash2 的调用 | 对 in 算哈希的次数 |
|---|---|---|---|
hash1.count(in) && hash2[in]++ < hash1[in] | count + operator[] = 2 次 | 1 次 | 3 次 |
find(in) + it->second | find = 1 次 | 1 次 | 2 次 |
关键点:
it->second是解引用迭代器,不查表、不算哈希(哈希在find时已经算过,迭代器直接指向节点);hash1[in]是又一次独立调用,标准库不会因为刚调用过count(in)就缓存参数的哈希。
所以准确的说法是:
count和find单次同复杂度;差别在于find一次调用就同时拿到了"在不在"和"值是多少",而count只拿到"在不在",值还得再查一次。
9.2 改法
auto it = hash1.find(in);
if (it != hash1.end() && hash2[in]++ < it->second) count++;
弹出同理:
auto jt = hash1.find(out);
if (jt != hash1.end() && hash2[out]-- <= jt->second) count--;
9.3 但别把它当"复杂度优化"
渐近复杂度完全一样:
你的版本:n 块 × 3 次哈希 = O(n·len)
find 版本:n 块 × 2 次哈希 = O(n·len)
只是命中时少了约 1/3 的哈希计算。本题 n ≤ 1e4、len ≤ 30,总块数才 1e4 量级,这点差异对 AC 毫无影响。
真要抠常数,substr 的堆分配比这几次 map 查找贵得多,改成 string_view 收益更大:
string_view in(s.data() + right, len); // C++17,零拷贝
9.4 顺手记一个"一次查找"的写法
如果确实想把每块压到"一次查找",可以把需求和窗口量塞进同一个节点:
struct Node { int need = 0, have = 0; };
unordered_map<string, Node> book;
for (auto &w : words) book[w].need++;
加入时:
auto it = book.find(in);
if (it != book.end()) {
if (it->second.have < it->second.need) ++count;
++it->second.have;
}
弹出时:
auto jt = book.find(out);
if (jt != book.end()) {
if (jt->second.have <= jt->second.need) --count;
--jt->second.have;
}
每块 1 次哈希 + 1 次查找。代价是每个相位要重建/重置所有 have(O(不同词数),最多 m,总量 O(m·len)),或者给每个词编个 id、用 vector<int> 做 O(1) 数组访问。
对本题来说属于"为了常数写更多代码",面试时没必要,知道有这条路即可。
10. 最终代码
class Solution {
public:
vector<int> findSubstring(string s, vector<string>& words) {
unordered_map<string, int> need;
for (auto &w : words) need[w]++;
int len = words[0].size(), m = words.size();
int n = s.size();
if (1LL * m * len > n) return {}; // 提前剪枝
vector<int> ans;
for (int phase = 0; phase < len; phase++) {
unordered_map<string, int> have; // 每个相位独立账本
for (int l = phase, r = phase, valid = 0; r + len <= n; r += len) {
// 加入一个块
string in = s.substr(r, len);
auto it = need.find(in);
if (it != need.end() && have[in]++ < it->second) valid++;
// 块数超过 m,弹出一个块
if (r - l + 1 > len * m) {
string out = s.substr(l, len);
l += len;
auto jt = need.find(out);
if (jt != need.end() && have[out]-- <= jt->second) valid--;
}
if (valid == m) ans.push_back(l);
}
}
return ans;
}
};
几处小细节:
for (auto &s : words)里的s会遮蔽函数参数s,改名w更清楚;right + len <= s.size()是int和size_t混比,先取int n = s.size();m * len用1LL防溢出(本题最大150000,其实不会溢出,但习惯成自然);- 窗口块数超了就用
if,因为每轮right只加一块,最多超一块。
11. 正确性:三个问题
Q1:所有合法起点都被检查到了吗?
任一合法子串的块边界必为 start + k·len,所以它必然属于 start % len 那个相位。len 个相位都跑了,覆盖所有起点。
Q2:窗口是"恰好"匹配吗?
检查点处窗口长度 ≤ m·len,即块数 ≤ m;而 valid == m 意味着每个词都已被满足,块数 ≥ m。两边夹住 ⇒ 块数恰好 m、多重集恰好相等。
Q3:valid 数得准吗?
由 valid = Σ min(have, need) 的不变量,加入/弹出按 7.3 的规则更新,始终维持等式;而 valid == m = Σ need 等价于每个 have[w] ≥ need[w] 且总量相等。
12. 复杂度
时间:O(n · len)
- 所有相位的块数总和 ≈
n(len个相位,每个相位约n / len块); - 每块的主要开销是
substr拷贝 + 哈希,各O(len); - 总字符量约
n · len,本题最大3 × 10^5,非常宽裕。
空间:O(m · len)
need存m个词,每词长len;have最多m个键(每个相位重建,不会跨相位累积)。
对比暴力:
| 方案 | 时间复杂度 | 本题量级 |
|---|---|---|
| 暴力枚举 + 逐块比对 | O(n·m·len) | 1.5 × 10^9 |
| 分组滑动窗口 | O(n·len) | 3 × 10^5 |
差三个数量级。
13. 坑点清单
| # | 坑 | 后果 | 怎么防 |
|---|---|---|---|
| 1 | hash2 没按相位重置 | 状态污染,只漏不多 | 把 hash2 定义进相位循环 |
| 2 | 用 set 而不是计数 map | 重复词直接判错 | 用 unordered_map<string,int> |
| 3 | count 和 hash2 更新不同步 | 不变量破坏,时对时错 | 加/删都走同一套 min 规则 |
| 4 | 收缩用 while 而不是 if | 可能多弹(本题每轮只超一块) | 想清楚"每轮最多超几块" |
| 5 | hash1[in] 不判存在 | 往 hash1 插垃圾键,map 膨胀 | 加 count/find 守卫 |
| 6 | 加入加了守卫、弹出忘了 | hash2 出现负数,count 错乱 | 加/删守卫必须对称 |
| 7 | int 与 size_t 混比 | 警告,极端情况逻辑错 | 先取 int n = s.size() |
| 8 | 没判 m·len > n | 白跑一轮 | 开头提前返回 |
| 9 | 忘记词可能重复 | 答案缺失 | 计数,不计数就错 |
| 10 | substr 到处都是 | 常数偏大 | 需要时换 string_view |
14. 横向对比
| 方案 | 时间 | 空间 | 关键假设 | 典型场景 |
|---|---|---|---|---|
| 枚举起点 + 逐块比对 | O(n·m·len) | O(m·len) | 无 | 对拍用 |
| 枚举起点 + 窗口排序 | O(n·m log m·len) | 同上 | 无 | 更慢,不推荐 |
| 分相位定长滑窗(本文) | O(n·len) | O(m·len) | 词等长、恰好用完 | 本题、567、438 |
| 不定长双指针(need/have) | O(n)(字符级) | O(Σ) | 允许"包含" | 76 最小覆盖子串 |
| Trie / 回溯 / DP | 最坏指数 | O(总词长) | 词可不等长 | 单词拆分类 |
| AC 自动机 | O(n + 总词长) | O(总词长·字符集) | 多模式、允许重叠 | 敏感词、出现次数 |
| 前缀哈希 / Rabin-Karp | O(n)(期望) | O(n) | 需防碰撞 | len 大、n 大时提常数 |
15. 还能复用到哪
- 定长窗口 + 频次表(
len = 1的退化情形,只跑一个相位):- 567 字符串的排列
- 438 找到字符串中所有字母异位词
- 本质是同一份代码:把"字母"换成"词"。
need / have需求计数:- 76 最小覆盖子串:窗口不定长、收缩用
while、找"最小"而非"恰好";本文是它的"定长简化版"。 - 面试题 17.18 最短超串:同样是"覆盖计数"。
- 76 最小覆盖子串:窗口不定长、收缩用
- 按模分组 / 相位分解(不限于字符串):
- 把"所有
i ≡ r (mod k)的位置"作为一个独立子问题,是处理周期性 / 网格对齐问题的通用手法; - 例:3137 K 周期字符串的最少操作次数,就是按
i % k分组统计众数; - 也可迁移到"矩阵按行/列/对角线分组"“等间隔采样序列”。
- 把"所有
- 可增量维护的判定量:把"是否匹配"设计成一个加/删都
O(1)更新的标量(valid),是滑动窗口题的工程核心。 - 字符串 → ID 的映射:
unordered_map<string,int>实际在给词编 ID;换成前缀哈希/双哈希,就是 Rabin-Karp 版本。
16. 背下来的模板
1. 模式串是否等长?
├─ 是 → 设 len,窗口总长 = m·len,进入 2
└─ 否 → 放弃分相位,考虑 Trie / DP / AC
2. 要求"恰好用完"还是"包含即可"?
├─ 恰好 → 定长窗口(块数固定 m),valid == m 即答案
└─ 包含 → 不定长窗口,while 收缩找最小(76 套路)
3. 枚举相位 phase = 0 .. len-1
4. 组内滑动:r += len 加块,超长则 l += len 弹块
5. 用 valid = Σ min(have[w], need[w]) 增量维护匹配度
6. valid == m 时记录 l
7. 自查:hash2 是否每组重置?收缩是否只需一次?加/删是否对称?两端是否都在网格上?
for (int phase = 0; phase < len; phase++) {
unordered_map<string, int> have; // 必须每组新建!
int valid = 0;
for (int l = phase, r = phase; r + len <= n; r += len) {
string in = s.substr(r, len);
auto it = need.find(in);
if (it != need.end() && have[in]++ < it->second) valid++;
if (r - l + 1 > len * m) { // 块数超了,弹一块
string out = s.substr(l, len);
l += len;
auto jt = need.find(out);
if (jt != need.end() && have[out]-- <= jt->second) valid--;
}
if (valid == m) ans.push_back(l);
}
}
17. 版本演进一览
| 版本 | 相对上一版改了什么 | 结果 | 教训 |
|---|---|---|---|
| V1 | hash2 放在相位循环外 | 159/183,偶数对奇数全丢 | 分组题的共享状态必须按组清零 |
| V2 | hash2 移进相位循环 | AC | 一行位置,决定对错 |
| V3 | 加 hash1.count 守卫 | AC,hash1/hash2 不再被垃圾键污染 | 加/删守卫必须对称 |
| V4 | find 复用迭代器 | AC,命中时少一次哈希 | count + [ ] 是两次查找;但只是常数优化 |
| V5(可选) | need/have 合并进一个节点 | 每块只查一次表 | 代码变长、要处理重置,收益有限 |
最后留一句话给下次的自己:
看到"等长模式串 + 恰好用完",先想分相位,再想定长滑窗,最后想用
min维护匹配度。
动笔前先问:每组开始时,哪些状态必须清零?
如果这篇对你有帮助,欢迎点赞收藏。下一篇可以聊聊 76 最小覆盖子串——把定长窗口换成不定长,need/have 是同一套思想。
822



被折叠的 条评论
为什么被折叠?



