271 lines
11 KiB
Markdown
271 lines
11 KiB
Markdown
---
|
||
tags: ["LeetCode", "滑动窗口", "哈希表", "中等"]
|
||
create time: 2026-05-14 10:30
|
||
---
|
||
|
||
# 09-找到字符串中所有字母异位词
|
||
|
||
## 题面
|
||
|
||
给定两个字符串 `s` 和 `p`，找到 `s` 中所有 `p` 的 **异位词** 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。
|
||
|
||
> [!question] 💡 什么是"异位词"？
|
||
> 两个字符串包含完全相同的字符，且每个字符出现的次数也相同——仅仅是排列顺序不同。例如 `"abc"` 和 `"cba"`、`"bca"` 互为异位词。
|
||
|
||
**示例 1：**
|
||
|
||
```
|
||
输入: s = "cbaebabacd", p = "abc"
|
||
输出: [0,6]
|
||
解释:
|
||
起始索引等于 0 的子串是 "cba"，它是 "abc" 的异位词。
|
||
起始索引等于 6 的子串是 "bac"，它是 "abc" 的异位词。
|
||
```
|
||
|
||
**示例 2：**
|
||
|
||
```
|
||
输入: s = "abab", p = "ab"
|
||
输出: [0,1,2]
|
||
解释:
|
||
起始索引等于 0 的子串是 "ab"，它是 "ab" 的异位词。
|
||
起始索引等于 1 的子串是 "ba"，它是 "ab" 的异位词。
|
||
起始索引等于 2 的子串是 "ab"，它是 "ab" 的异位词。
|
||
```
|
||
|
||
**提示：**
|
||
|
||
- `1 <= s.length, p.length <= 3 * 10^4`
|
||
- `s` 和 `p` 仅包含小写英文字母
|
||
|
||
---
|
||
|
||
## 思路
|
||
|
||
> [!info] 🎯 核心观察
|
||
> 异位词的长度是固定的（等于 `len(p)`），所以本质上是：在字符串 `s` 上维护一个**长度固定为 len(p)** 的滑动窗口，逐一检查窗口内的字符组成是否与 `p` 一致。这比一般的"可变长窗口"更简单——左指针的移动节奏由右指针决定：每前进一格，左右各前进一步。
|
||
|
||
### 方法一：暴力枚举 ❌
|
||
|
||
枚举 `s` 中所有长度为 `len(p)` 的子串，对每个子串排序后与排序后的 `p` 比较。
|
||
|
||
- **时间复杂度：O((m-n+1) · n · log n)** — 每个子串排序需要 O(n log n)，共有 m-n+1 个子串（m = len(s)）
|
||
- **空间复杂度：O(n)** — 排序需要的额外空间
|
||
|
||
当 `n` 较大时，这种做法明显超时，需要利用"滑动窗口增量更新"来避免重复排序。
|
||
|
||
### 方法二：定长滑动窗口 + 计数数组 ⭐（最优）
|
||
|
||
> [!abstract] 🔍 为什么用数组而非哈希表？
|
||
> 题目限定只包含小写英文字母，字符集大小固定为 26。此时用 `int[26]` 数组比 `map[rune]int` 哈希表更快——数组不存在 hash 计算开销，内存也更紧凑。
|
||
|
||
#### 算法步骤
|
||
|
||
**第一步：统计 `p` 中各字符出现频次。**
|
||
|
||
用一个长度为 26 的数组 `pCount` 记录 `p` 的字符频率分布。
|
||
|
||
**第二步：在 `s` 上维护长度为 `len(p)` 的滑动窗口。**
|
||
|
||
初始时，让窗口覆盖 `s[0..len(p)-1]`。这里需要**分别统计**——`pCount` 记录 `p` 的字符频率，`windowCount` 记录窗口内（即 `s[0..len(p)-1]`）的字符频率，然后比较两者是否相等。之后每次窗口向右移动一格：新字符从右侧进入窗口并计入 `windowCount`，左侧离开窗口的字符从 `windowCount` 中减去。每次移动后再次比较两个数组。
|
||
|
||
```mermaid
|
||
flowchart TD
|
||
Start["初始化 pCount 统计 p 的字符频次"] --> InitWin["初始化 windowCount 统计 s 前 n 个字符频次"]
|
||
InitWin --> CheckStart{"pCount == windowCount"}
|
||
CheckStart -->|"是"| Add0["将索引 0 加入结果"]
|
||
CheckStart -->|"否"| SkipStart["跳过"]
|
||
Add0 --> EnterLoop["进入循环 i 从 n 到 m-1"]
|
||
SkipStart --> EnterLoop
|
||
EnterLoop --> RightIn["右进新字符加入窗口"]
|
||
RightIn --> LeftOut["左出旧字符离开窗口"]
|
||
LeftOut --> CheckWin{"pCount == windowCount"}
|
||
CheckWin -->|"是"| AddIdx["将索引 i-n+1 加入结果"]
|
||
CheckWin -->|"否"| SkipWin["跳过"]
|
||
AddIdx --> LoopCheck{"i < m"}
|
||
SkipWin --> LoopCheck
|
||
LoopCheck -->|"是"| EnterLoop
|
||
LoopCheck -->|"否"| ReturnRes["返回结果数组"]
|
||
```
|
||
|
||
#### 逐步推演
|
||
|
||
以 `s = "abab", p = "ab"` 为例（匹配场景）：
|
||
|
||
| 阶段 | 操作 | pCount | windowCount | 匹配? | 结果 |
|
||
|------|------|--------|-------------|-------|------|
|
||
| 初始化窗口 | 统计 `s[0..1]="ab"` | `{a:1, b:1}` | `{a:1, b:1}` | ✅ | `[0]` |
|
||
| 窗口右移 (i=2) | 进 `'a'`，出 `s[0]='a'` | `{a:1, b:1}` | `{a:1, b:1}` | ✅ | `[0, 1]` |
|
||
| 窗口右移 (i=3) | 进 `'b'`，出 `s[1]='b'` | `{a:1, b:1}` | `{a:1, b:1}` | ✅ | `[0, 1, 2]` |
|
||
|
||
再看一个有匹配也有不匹配的例子 `s = "cbaebabacd", p = "abc"`（以下为完整推演，超出原题示例范围）：
|
||
|
||
| i | 窗口内容 | 窗口频次分布 | 匹配? | 结果追加 |
|
||
|----|---------|------------|-------|---------|
|
||
| 初始 | `"cba"` | `{a:1, b:1, c:1}` | ✅ | `[0]` |
|
||
| 3 | `"bae"` | `{a:1, b:1, e:1}` | ❌ | — |
|
||
| 4 | `"aeb"` | `{a:1, b:1, e:1}` | ❌ | — |
|
||
| 5 | `"eba"` | `{a:1, b:1, e:1}` | ❌ | — |
|
||
| 6 | `"bac"` | `{a:1, b:1, c:1}` | ✅ | `[0, 6]` |
|
||
| 7 | `"acb"` | `{a:1, b:1, c:1}` | ✅ | `[0, 6, 7]` |
|
||
| 8 | `"cba"` | `{a:1, b:1, c:1}` | ✅ | `[0, 6, 7, 8]` |
|
||
|
||
最终结果为 `[0, 6, 7, 8]`。（注意题目示例只列出前两个答案 `[0, 6]`，实际完整输出为全部四个索引。）
|
||
|
||
> [!note] 🧠 "右进左出"的增量更新技巧
|
||
> 窗口每次右移一格时，只需做两次 O(1) 的加减操作：`windowCount[newChar]++` 和 `windowCount[oldChar]--`，无需重新统计整个窗口。这是滑动窗口把时间复杂度从 O(m·n) 优化到 O(m) 的关键。
|
||
|
||
> [!tip] 🔑 数组比较的小优化
|
||
> 如果只想判断窗口状态有无变化，可以维护一个变量 `matches`（或 `diff`），记录当前有多少个位置的频次已经对齐。但这会增加代码复杂度，对于本题常数级比较（26次）而言优化意义不大，保持简洁即可。
|
||
|
||
**时间复杂度：O(m)** — 先遍历 `p` 一次 O(n)，再遍历 `s` 一次 O(m)。窗口内的数组比较虽然做了 26 次元素对比，但 26 是常量，均摊后仍为 O(m)。
|
||
|
||
**空间复杂度：O(1)** — 只用到了固定大小的数组（26 个整型元素）。
|
||
|
||
---
|
||
|
||
## 代码提示
|
||
|
||
```
|
||
// 伪代码模板
|
||
m = len(s)
|
||
n = len(p)
|
||
|
||
if n > m: return []
|
||
|
||
pCount = 数组[int](26) // 记录 p 的字符频次
|
||
windowCount = 数组[int](26) // 记录当前窗口的字符频次
|
||
|
||
// 初始化: 统计 p 和 s 前 n 个字符的频次
|
||
for i = 0 到 n-1:
|
||
pCount[p[i]-'a']++
|
||
windowCount[s[i]-'a']++
|
||
|
||
result = []
|
||
|
||
// 检查初始窗口
|
||
if arraysEqual(pCount, windowCount):
|
||
result.append(0)
|
||
|
||
// 滑动窗口: 逐个右移
|
||
for i = n 到 m-1:
|
||
windowCount[s[i]-'a']++ // 新字符入
|
||
windowCount[s[i-n]-'a']-- // 旧字符出
|
||
|
||
if arraysEqual(pCount, windowCount):
|
||
result.append(i - n + 1)
|
||
|
||
return result
|
||
```
|
||
|
||
Go 语言中利用数组类型天然支持 `==` 运算符的特性，可直接比较两个 `[26]int`：
|
||
|
||
```go
|
||
// Go 风格精简版骨架
|
||
var pCount, windowCount [26]int // [26]int 天然支持 == 比较
|
||
|
||
for _, ch := range p {
|
||
pCount[ch-'a']++
|
||
}
|
||
for i := 0; i < len(p); i++ {
|
||
windowCount[s[i]-'a']++
|
||
}
|
||
|
||
// 💡 Go 优化：预先分配容量，避免运行时多次扩容（上限为 m-n+1）
|
||
result := make([]int, 0, len(s)-len(p)+1)
|
||
|
||
if pCount == windowCount {
|
||
result = append(result, 0)
|
||
}
|
||
|
||
for i := len(p); i < len(s); i++ {
|
||
windowCount[s[i]-'a']++
|
||
windowCount[s[i-len(p)]-'a']--
|
||
if pCount == windowCount {
|
||
result = append(result, i-len(p)+1)
|
||
}
|
||
}
|
||
```
|
||
|
||
> [!note] 🐹 Go 中 `[26]int ==` 的特性
|
||
> Go 语言的数组是值类型，两个同构的 `[N]int` 数组可以直接用 `==` 逐元素比较，这在其他语言中并不常见。这省去了手写循环比对的时间，让代码异常简洁。
|
||
|
||
---
|
||
|
||
## 技巧
|
||
|
||
> [!tip] 🔑 固定窗口 vs 可变窗口
|
||
>
|
||
> | 场景 | 窗口行为 | 典型问题 |
|
||
> |------|---------|---------|
|
||
> | **固定长度** | 右指针每进一格，左指针也相应前进一格 | 字母异位词、大小为 K 的子数组平均值 |
|
||
> | **可变长度** | 左右指针独立运动，按条件伸缩 | 无重复字符最长子串、最小覆盖子串 |
|
||
>
|
||
> 本题是"固定窗口"范式——只要知道窗口大小 `n`，左右指针步调就锁定了：`left = right - n + 1`。识别这一点可以避免过度设计。
|
||
|
||
> [!info] 📊 字符集大小决定数据结构
|
||
>
|
||
> | 字符集限制 | 推荐方案 | 理由 |
|
||
> |-----------|---------|------|
|
||
> | 仅小写字母（如本题） | `[26]int` 数组 | 常数快、内存紧、Go 支持 `==` 直接比较 |
|
||
> | Unicode/任意字符 | `map[rune]int` | 灵活但慢，Go 中不支持 `==` 比较 map |
|
||
>
|
||
> 面试时可以主动确认："题目中的字符范围是否可以用定长数组表示？"这体现了你对边界条件的敏感度。
|
||
|
||
> [!danger] ⚠️ 常见陷阱
|
||
>
|
||
> **① p 的长度大于 s**：此时不可能存在异位词，应提前返回空数组。否则窗口初始化时会越界访问 `s[n-1]`。
|
||
>
|
||
> **② 混淆异位词与最长公共子串**：异位词只看字符集合和频次，不要求连续或有序。例如 `"abc"` 的异位词是 `"acb"`, `"bca"`, `"cab"`, `"cba"` 等全排列。
|
||
>
|
||
> **③ Go 中 string 索引返回的是 byte 而非 rune**：由于题目限定仅含小写字母，每个字符恰好占 1 字节，直接用 `s[i]-'a'` 是正确的。但如果题目涉及多字节 Unicode 字符，则必须改用 `[]rune(s)` 转换后再索引。
|
||
|
||
---
|
||
|
||
## 代码
|
||
|
||
```go
|
||
func findAnagrams(s string, p string) []int {
|
||
m, n := len(s), len(p)
|
||
if n > m {
|
||
return nil
|
||
}
|
||
|
||
var pCount, windowCount [26]int // 统计字符频次，[26]int 天然支持 == 比较
|
||
|
||
// 初始化: 分别统计 p 和 s 的前 n 个字符的频次
|
||
for _, ch := range p {
|
||
pCount[ch-'a']++
|
||
}
|
||
for i := 0; i < n; i++ {
|
||
windowCount[s[i]-'a']++
|
||
}
|
||
|
||
// 💡 预分配容量，避免运行时多次扩容（上限为 m-n+1）
|
||
result := make([]int, 0, m-n+1)
|
||
|
||
// 检查第一个窗口
|
||
if pCount == windowCount {
|
||
result = append(result, 0)
|
||
}
|
||
|
||
// 滑动窗口: 逐个右移
|
||
for i := n; i < m; i++ {
|
||
windowCount[s[i]-'a']++ // 新字符从右侧进入窗口
|
||
windowCount[s[i-n]-'a']-- // 左侧字符离开窗口
|
||
|
||
if pCount == windowCount {
|
||
result = append(result, i-n+1)
|
||
}
|
||
}
|
||
|
||
return result
|
||
}
|
||
```
|
||
|
||
> [!success] ✅ 运行验证
|
||
> - **LeetCode 第 438 题**，通过率约 56%，中等难度中滑动窗口的经典应用。
|
||
> - 这道题的核心洞察是：**异位词的本质是"字符频次分布相同"**。只要窗口内各字符的出现次数与 `p` 一模一样，无论顺序如何，就是异位词。固定长度的窗口设计让左右指针的运动被完全绑定，简化了逻辑。
|
||
> - 与 [[08-无重复字符的最长子串]] 对比：后者是"最大化窗口"（窗口可缩可扩），本题是"固定窗口"（窗口大小锁定）。两者的共同点都是利用增量更新避免重复计算，是理解滑动窗口的两块基石。
|
||
> - **变体延伸**：若将"完全匹配"放宽为"至多差 k 个字符"（LeetCode 2425 思路的变形），则可将数组比较替换为维护一个 `diff` 计数器——记录当前有多少个位置的频次对齐，仅当 `diff == 26` 时才记入答案，时间复杂度仍为 O(m)。
|