滑动窗口算法解决字母异位词匹配问题

张牛顿

1. 问题背景与定义

字母异位词（Anagram）是指由相同字母重新排列组合形成的不同单词或短语。比如"listen"和"silent"就是一组典型的字母异位词。在实际开发中，处理字符串匹配问题时经常会遇到这类需求。

给定一个字符串s和一个非空字符串p，我们需要找到s中所有是p的字母异位词的子串，返回这些子串的起始索引。例如：

输入：s = "cbaebabacd", p = "abc"
输出：[0, 6]
解释：
起始索引0的子串"cba"是"abc"的字母异位词
起始索引6的子串"bac"是"abc"的字母异位词

2. 核心算法解析

2.1 滑动窗口算法原理

解决这类字符串匹配问题的经典方法是滑动窗口（Sliding Window）算法。该算法通过维护一个固定大小的窗口在字符串上滑动，高效地检查所有可能的子串。

滑动窗口算法的优势在于：

时间复杂度优化：将暴力解法的O(n^2)降低到O(n)
空间效率：只需要常数级别的额外空间
适合处理连续子串/子数组问题

2.2 具体实现步骤

初始化哈希表：
- 创建两个哈希表（或数组）分别记录p的字符频率和当前窗口的字符频率
- 对于p = "abc"，其哈希表为：
设置窗口指针：
- 使用left和right两个指针表示窗口的左右边界
- 初始时left = right = 0
滑动窗口过程：
- 移动right指针，将s[right]加入当前窗口的哈希表
- 当窗口大小等于p的长度时，比较两个哈希表
- 如果匹配，记录left索引
- 移动left指针，移除s[left]的计数

2.3 代码实现示例

python复制from collections import defaultdict

def findAnagrams(s: str, p: str) -> List[int]:
    if len(s) < len(p):
        return []
    
    p_count = defaultdict(int)
    window_count = defaultdict(int)
    
    # 初始化p的字符计数
    for char in p:
        p_count[char] += 1
    
    result = []
    left = 0
    
    for right in range(len(s)):
        # 添加当前字符到窗口
        window_count[s[right]] += 1
        
        # 当窗口大小等于p的长度时开始比较
        if right - left + 1 == len(p):
            if window_count == p_count:
                result.append(left)
            
            # 移动左指针，移除最左边的字符
            window_count[s[left]] -= 1
            if window_count[s[left]] == 0:
                del window_count[s[left]]
            left += 1
    
    return result

3. 算法优化与变种

3.1 使用数组替代哈希表

对于仅包含小写字母的情况，可以用长度为26的数组代替哈希表，提升效率：

python复制def findAnagrams(s: str, p: str) -> List[int]:
    if len(s) < len(p):
        return []
    
    p_count = [0] * 26
    window_count = [0] * 26
    
    for char in p:
        p_count[ord(char) - ord('a')] += 1
    
    result = []
    left = 0
    
    for right in range(len(s)):
        window_count[ord(s[right]) - ord('a')] += 1
        
        if right - left + 1 == len(p):
            if window_count == p_count:
                result.append(left)
            
            window_count[ord(s[left]) - ord('a')] -= 1
            left += 1
    
    return result

3.2 匹配计数优化

可以引入一个match变量来记录匹配的字符数，避免每次全量比较哈希表：

python复制def findAnagrams(s: str, p: str) -> List[int]:
    if len(s) < len(p):
        return []
    
    p_count = [0] * 26
    window_count = [0] * 26
    
    for char in p:
        p_count[ord(char) - ord('a')] += 1
    
    match = 0
    result = []
    
    for i in range(len(s)):
        # 右指针移动
        char = s[i]
        idx = ord(char) - ord('a')
        if p_count[idx] > 0:
            window_count[idx] += 1
            if window_count[idx] == p_count[idx]:
                match += 1
        
        # 左指针移动条件
        if i >= len(p):
            left_char = s[i - len(p)]
            left_idx = ord(left_char) - ord('a')
            if p_count[left_idx] > 0:
                if window_count[left_idx] == p_count[left_idx]:
                    match -= 1
                window_count[left_idx] -= 1
        
        # 检查匹配
        if match == len(set(p)):
            result.append(i - len(p) + 1)
    
    return result