(day26)leecode热题——找到字符串中所有字母异位词

描述

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

示例 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 * 104
s 和 p 仅包含小写字母

超时代码

class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        li = [s[i:i+len(p)] for i in range(0, len(s)-len(p)+1, 1)]
        lis = []
        for i in range(len(li)):
            if sorted(li[i]) == sorted(p):
                lis.append(i)
            else:
                continue
        return lis

leecode题解labuladong

from collections import Counter, defaultdict
class Solution:
    def findAnagrams(self, s: str, p: str) -> List[int]:
        need = Counter(p)  # 统计目标字符串t中每个字符的频率
        window = defaultdict(int)  # 记录窗口中字符的频率
        
        left, right = 0, 0  # 左右指针初始化
        valid = 0  # 记录当前窗口中满足条件的字符数
        res = []  # 存储结果的列表

        while right < len(s):  # 遍历字符串s
            c = s[right]  # 当前字符
            right += 1  # 移动右指针
            # 进行窗口内数据的一系列更新
            if c in need:
                window[c] += 1
                if window[c] == need[c]:
                    valid += 1
            
            # 判断左侧窗口是否需要收缩
            while right - left >= len(p):
                # 当窗口符合条件时，把起始索引加入res
                if valid == len(need):
                    res.append(left)
                d = s[left]  # 要移出窗口的字符
                left += 1  # 移动左指针
                # 进行窗口内数据的一系列更新
                if d in need:
                    if window[d] == need[d]:
                        valid -= 1
                    window[d] -= 1

        return res

整体分析

1. 初始化阶段

统计目标字符串 t 中每个字符的频率：使用 Counter 创建字典 need，记录 t 中每个字符的频率。
初始化窗口字典：使用 defaultdict(int) 创建字典 window，用于记录当前窗口中字符的频率。
设置左右指针：初始化左右指针 left 和 right 均为0。
初始化辅助变量：变量 valid 用于记录当前窗口中满足条件的字符数。列表 res 用于存储结果，即符合条件的起始索引。

2. 扩展右边界

遍历字符串 s：使用 while 循环遍历字符串 s，右指针 right 从左到右移动。
更新窗口字符频率：将 right 指针指向的字符加入窗口，更新 window 字典中该字符的频率。
检查是否满足条件：如果该字符在 need 字典中，并且其频率与 need 中的频率一致，则更新 valid 计数。

3. 收缩左边界

判断窗口大小：当窗口的大小达到字符串 t 的长度时，进入内层 while 循环。
检查窗口是否符合条件：如果当前窗口中的字符频率与 t 中字符频率一致，则将 left 指针的位置加入结果列表 res。
收缩窗口：移动 left 指针，缩小窗口，并更新窗口中左边字符的频率。
更新满足条件的字符数：如果移除的字符在 need 字典中，并且其频率在窗口中不再满足 need 的要求，则更新 valid 计数。

4. 返回结果

输出结果列表：当所有字符遍历完成后，返回结果列表 res，其中存储了所有符合条件的起始索引。

关键点

滑动窗口：通过左右指针维护一个大小为 t 长度的窗口。
频率统计：使用 Counter 和 defaultdict 统计字符频率。
条件判断：通过 valid 判断当前窗口是否符合条件。
结果存储：符合条件时，将窗口的起始索引存储到结果列表中。

滑动窗口

维护一个窗口，不断滑动，然后更新答案。算法技巧的时间复杂度是 O(N)，比字符串暴力算法要高效得多。细节：如何向窗口中添加新元素，如何缩小窗口，在窗口滑动的哪个阶段更新结果。

python框架

from collections import defaultdict

def sliding_window(s, t):
    # 创建need字典，记录目标字符串t中每个字符的频率
    need = defaultdict(int)
    for c in t:
        need[c] += 1

    window = defaultdict(int)  # 创建window字典，记录当前窗口中每个字符的频率
    left, right = 0, 0  # 初始化左、右指针
    valid = 0  # 记录当前窗口中满足条件的字符数

    while right < len(s):
        # c 是将移入窗口的字符
        c = s[right]
        # 右移窗口
        right += 1
        # 进行窗口内数据的一系列更新
        # 此处应填写窗口右移时的处理逻辑
        ...

        # debug 输出的位置
        print(f"window: [{left}, {right})")

        # 判断左侧窗口是否要收缩
        while window_needs_shrink():  # 此处应填写判断窗口是否需要收缩的条件
            # d 是将移出窗口的字符
            d = s[left]
            # 左移窗口
            left += 1
            # 进行窗口内数据的一系列更新
            # 此处应填写窗口左移时的处理逻辑
            ...

def window_needs_shrink():
    # 这是一个占位函数，用于判断窗口是否需要收缩
    # 你需要根据具体逻辑实现该函数
    return False

其中两处 ... 表示的更新窗口数据的地方，到时候你直接往里面填就行了。

而且，这两个 ... 处的操作分别是右移和左移窗口更新操作，等会你会发现它们操作是完全对称的。

框架说明

上述Python框架代码主要涉及以下几个重要的知识点和数据结构：

1. defaultdict

from collections import defaultdict

- **定义**：`defaultdict` 是 `collections` 模块中的一个类，它继承自内置的 `dict` 类。与普通字典不同的是，`defaultdict` 在访问不存在的键时，不会抛出 `KeyError`，而是会根据提供的默认工厂函数生成一个默认值。
- **用途**：在需要频繁处理不存在的键的情况下，`defaultdict` 可以简化代码，避免手动检查键是否存在。

need = defaultdict(int)
for c in t:
    need[c] += 1

在这里，`need` 是一个 `defaultdict`，默认值为 `int` 类型，即默认值为 0。这样，在统计字符频率时，如果某个字符在 `need` 中不存在，会自动添加并初始化为 0。

2. 滑动窗口

滑动窗口是一种常用于字符串或数组问题的算法技巧，用于在一维数据结构中维护一个动态范围（窗口）并根据特定条件进行调整。

- **用途**：适用于需要在一维数据结构（如字符串或数组）中查找满足特定条件的子数组或子字符串的问题。
- **核心思想**：通过两个指针（左指针 `left` 和右指针 `right`）维护一个窗口，动态调整窗口大小，移动窗口的位置以找到符合条件的子数组或子字符串。
- **示例**：

left, right = 0, 0
while right < len(s):
    c = s[right]
    right += 1
    ...
    while window_needs_shrink():
        d = s[left]
        left += 1
        ...

3. 字符频率统计

使用字典或 `defaultdict` 统计字符串中字符的频率，是处理字符串问题的常用技巧。

- **用途**：在涉及字符串比较、匹配等操作时，字符频率统计是一个基础步骤。
- **示例**：

need = defaultdict(int)
for c in t:
    need[c] += 1

在这里，`need` 字典用于统计字符串 `t` 中每个字符的频率。

4. 占位符函数

def window_needs_shrink():
    return False

- **用途**：在初步搭建框架时，占位符函数用于表示某个需要实现的具体逻辑。
- **实现**：在实际应用中，这个函数需要根据特定问题的需求进行实现，以判断窗口是否需要收缩。

5. 字符串操作

在字符串中，通过索引访问字符是常见的操作。

- **示例**：

c = s[right]  # 获取当前右指针指向的字符
d = s[left]   # 获取当前左指针指向的字符

通过这种方式，可以获取窗口左右边界的字符，进行相应的逻辑处理。

总结

上述代码框架结合了 `defaultdict`、滑动窗口、字符频率统计等数据结构和算法技巧，为解决类似字符串匹配或子数组查找的问题提供了基础结构。通过填充具体的逻辑，可以实现特定功能的滑动窗口算法。

速记口诀

整体思路

滑动窗口算法的思路是这样：

1、我们在字符串 S 中使用双指针中的左右指针技巧，初始化 left = right = 0，把索引左闭右开区间 [left, right) 称为一个「窗口」。

2、我们先不断地增加 right 指针扩大窗口 [left, right)，直到窗口中的字符串符合要求（包含了 T 中的所有字符）。

3、此时，我们停止增加 right，转而不断增加 left 指针缩小窗口 [left, right)，直到窗口中的字符串不再符合要求（不包含 T 中的所有字符了）。同时，每次增加 left，我们都要更新一轮结果。

4、重复第 2 和第 3 步，直到 right 到达字符串 S 的尽头。

这个思路其实也不难，**第 2 步相当于在寻找一个「可行解」，然后第 3 步在优化这个「可行解」，最终找到最优解，**也就是最短的覆盖子串。左右指针轮流前进，窗口大小增增减减，窗口不断向右滑动，这就是「滑动窗口」这个名字的来历。

下面画图理解一下，needs 和 window 相当于计数器，分别记录 T 中字符出现次数和「窗口」中的相应字符的出现次数。

初始状态：

{:align=center}

增加 right，直到窗口 [left, right) 包含了 T 中所有字符：

{:align=center}

现在开始增加 left，缩小窗口 [left, right)。

{:align=center}

直到窗口中的字符串不再符合要求，left 不再继续移动。

{:align=center}

之后重复上述过程，先移动 right，再移动 left…… 直到 right 指针到达字符串 S 的末端，算法结束。