1
class Solution:
2
    def minWindow(self, s: str, t: str) -> str:
3

4
        count_s = Counter()       # 当前窗口内各字符的出现次数（动态更新）
5
        count_t = Counter(t)      # t 中各字符的出现次数（固定不变）
6

7
        final_right = len(s)      # 最短合法窗口的右端点，初始设为 len(s)
8
        final_left = -1           # 最短合法窗口的左端点，初始设为 -1（表示还没找到）
9
        left = 0                  # 滑动窗口的左端点
10

11
        for right, char in enumerate(s):   # 右端点从左到右遍历 s
12
            count_s[char] += 1             # 右端点字符移入窗口
13

14
            while count_s >= count_t:      # 当前窗口已涵盖 t（每种字符数量都够）
15
                if right - left + 1 < final_right - final_left + 1:  # 找到更短的合法窗口
16
                    final_left = left      # 更新最短窗口的左端点
17
                    final_right = right    # 更新最短窗口的右端点
18
                count_s[s[left]] -= 1      # 左端点字符移出窗口
19
                left += 1                  # 左端点右移，收缩窗口
20

21
        if final_left < 0:                 # final_left 仍为 -1，说明从未找到合法窗口
22
            return ""
23
        else:
24
            return s[final_left:final_right + 1]   # 返回最短合法子串

1
class Solution:
2
    def findAnagrams(self, s: str, p: str) -> List[int]:
3

4
        count_s = Counter()    # 当前窗口内各字符的出现次数
5
        count_p = Counter(p)   # p 中各字符的出现次数（固定不变）
6

7
        ans = []
8
        left = 0               # 窗口左端点
9

10
        for right, char in enumerate(s):          # 右端点从左到右遍历 s
11
            count_s[char] += 1                    # 右端点字符移入窗口
12

13
            if right - left + 1 == len(p):        # 窗口长度恰好等于 p 的长度
14
                if count_s == count_p:            # 窗口内字符与 p 完全一致，是异位词
15
                    ans.append(left)              # 记录左端点（异位词起始索引）
16

17
                count_s[s[left]] -= 1             # 左端点字符移出窗口
18

19
                if count_s[s[left]] == 0:         # 如果该字符数量降为 0
20
                    del count_s[s[left]]          # 必须删掉，否则 == 比较会误判
21
                                                  # 例：{'A':0,'B':1} != {'B':1}
22
                left += 1                         # 左端点右移
23

24
        return ans

1
from collections import deque
2

3
class Solution:
4
    def minDepth(self, root: Optional[TreeNode]) -> int:
5
        if not root:              # 空树，深度为 0
6
            return 0
7

8
        queue = deque([root])     # 队列初始化，根节点入队
9
        depth = 0                 # 当前层数（深度）
10

11
        while queue:              # 队列不为空，说明还有节点未处理
12
            depth += 1            # 进入新的一层，深度 +1
13

14
            for _ in range(len(queue)):   # 只处理当前层的节点（len 在进入循环时固定）
15
                node = queue.popleft()    # 取出当前层的一个节点
16

17
                if node.left:             # 左子节点存在，加入下一层队列
18
                    queue.append(node.left)
19
                if node.right:            # 右子节点存在，加入下一层队列
20
                    queue.append(node.right)
21

22
                if not node.left and not node.right:   # 遇到叶子节点
23
                    return depth                       # 当前层数就是最小深度，直接返回
24

25
        return depth

1
from collections import deque
2

3
queue = deque([起点])
4
visited = set([起点])   # 防止重复访问（图题必须，树可省略）
5
depth = 0               # 记录层数，不需要层数时可省略
6

7
while queue:
8
    depth += 1
9

10
    for _ in range(len(queue)):   # 关键：固定当前层的节点数
11
        node = queue.popleft()
12

13
        if node == 终点:           # 找到答案，直接返回
14
            return depth
15

16
        for neighbor in 邻居(node):       # 扩展下一层
17
            if neighbor not in visited:
18
                visited.add(neighbor)
19
                queue.append(neighbor)