phase 5 part 5: cs algorithms, network-os, web-security topics with tested examples; all 43 stacks pass --strict
This commit is contained in:
1 parent
f695bbd7cc
commit
691f738f5f
22 files changed
+1955
-37
No files matched your search
@@ -0,0 +1,104 @@
|
||||
---
|
||||
id: cs.algorithms.complexity-patterns
|
||||
title: 复杂度分析和九个高频模式:哈希、滑动窗口、二分、堆、BFS、拓扑排序、动态规划、LRU、区间合并
|
||||
type: lesson
|
||||
domain: cs
|
||||
stack: [algorithms]
|
||||
tags: [时间复杂度, 哈希表, 滑动窗口, 二分查找, 堆, Top K, BFS, DFS, 拓扑排序, 动态规划, LRU]
|
||||
level: basic
|
||||
prerequisites: [python.python.index]
|
||||
est_hours: 6
|
||||
related: [cs.algorithms.scenario.business-algorithms, cs.algorithms.interview]
|
||||
week: [16]
|
||||
order: 1
|
||||
---
|
||||
|
||||
# 复杂度分析和九个高频模式:哈希、滑动窗口、二分、堆、BFS、拓扑排序、动态规划、LRU、区间合并
|
||||
|
||||
> BOSS直聘 2026-10-23 的调研中有少数岗位明确提到算法 / 数据结构基础,笔试和一面中出现手写题的情况也不少。目标不是刷几百题,而是**掌握模式、能讲复杂度、写出无 bug 的中等题**。练习平台可用 LeetCode 中国站(力扣)。
|
||||
|
||||
## 解释说明
|
||||
|
||||
### 复杂度
|
||||
|
||||
| 复杂度 | 典型操作 | n = 10⁶ 时的感受 |
|
||||
| --- | --- | --- |
|
||||
| O(1) | 哈希表查找、数组下标 | 瞬间 |
|
||||
| O(log n) | 二分查找、堆操作 | 约 20 步 |
|
||||
| O(n) | 遍历 | 很快 |
|
||||
| O(n log n) | 排序 | 可以接受 |
|
||||
| O(n²) | 双重循环 | 太慢(10¹² 次) |
|
||||
|
||||
面试时先说暴力解及其复杂度,再优化,最后说明时间和空间复杂度。
|
||||
|
||||
### 九个模式(何时想到它)
|
||||
|
||||
| 模式 | 信号 | 例题 |
|
||||
| --- | --- | --- |
|
||||
| 哈希表 | “是否出现过”、“计数”、“配对” | 两数之和 |
|
||||
| 滑动窗口 | 连续子数组 / 子串 + 最长 / 最短 | 无重复字符的最长子串 |
|
||||
| 二分查找 | 有序、单调、“第一个满足条件的” | lower_bound、搜索旋转数组 |
|
||||
| 堆 | Top K、动态取最值、合并 K 个有序 | 前 K 个高频元素 |
|
||||
| BFS | 最短步数、层序遍历 | 网格最短路径 |
|
||||
| DFS / 拓扑排序 | 依赖关系、是否有环、所有方案 | 课程表 |
|
||||
| 动态规划 | 最优值 / 方案数、子问题重叠 | 编辑距离、爬楼梯、背包 |
|
||||
| 设计题 | 要求 O(1) 操作 | LRU 缓存 |
|
||||
| 排序 + 扫描 | 区间、会议室 | 合并区间 |
|
||||
|
||||
### 答题步骤
|
||||
|
||||
1. 复述题目,问清边界(空输入、重复、负数、数据规模);
|
||||
2. 说思路和复杂度,得到认可后再写;
|
||||
3. 写代码时变量命名清楚;
|
||||
4. 用一两个例子手动走一遍,包括边界;
|
||||
5. 说明可以改进的地方。
|
||||
|
||||
## 案例
|
||||
|
||||
这些模式在业务中经常出现:热门问题统计(堆)、限流的滑动窗口、任务编排的依赖顺序(拓扑排序,LangGraph / CI 流水线都用到)、文本纠错与相似度(编辑距离)、缓存淘汰(LRU)、排班时间段合并(区间合并)。见[企业场景](scenarios/business-algorithms.md)。
|
||||
|
||||
## 代码示例
|
||||
|
||||
[examples/patterns](examples/patterns/):9 个模式的实现 + 13 个测试(其中二分查找与标准库 `bisect` 随机对拍 200 次)。
|
||||
|
||||
滑动窗口:
|
||||
|
||||
```python
|
||||
def longest_unique_substring(s: str) -> int:
|
||||
last: dict[str, int] = {}
|
||||
left = best = 0
|
||||
for right, ch in enumerate(s):
|
||||
if last.get(ch, -1) >= left:
|
||||
left = last[ch] + 1
|
||||
last[ch] = right
|
||||
best = max(best, right - left + 1)
|
||||
return best
|
||||
```
|
||||
|
||||
二分查找(左闭右开,最不容易写错的模板):
|
||||
|
||||
```python
|
||||
def lower_bound(arr: list[int], target: int) -> int:
|
||||
lo, hi = 0, len(arr)
|
||||
while lo < hi:
|
||||
mid = (lo + hi) // 2
|
||||
if arr[mid] < target:
|
||||
lo = mid + 1
|
||||
else:
|
||||
hi = mid
|
||||
return lo
|
||||
```
|
||||
|
||||
## 易错点
|
||||
|
||||
- 二分查找的区间定义混乱(左闭右闭和左闭右开混用),导致死循环或越界。
|
||||
- 滑动窗口中,重复字符在窗口左边界之外时也移动左边界(例如 "abba")。
|
||||
- BFS 出队时才标记已访问,导致同一个节点多次入队。
|
||||
- 递归 DFS 在深度很大时栈溢出(Python 默认递归深度约 1000)。
|
||||
- 只写出代码不说复杂度。
|
||||
|
||||
## 面试常问
|
||||
|
||||
- 手写:两数之和、最长无重复子串、二分查找、Top K、LRU、合并区间、课程表、编辑距离 / 爬楼梯。
|
||||
- 哈希表的原理和冲突处理?
|
||||
- 快速排序的平均和最坏复杂度?
|
||||
@@ -0,0 +1,142 @@
|
||||
"""面试高频算法模式(只用标准库)。每个函数注明时间 / 空间复杂度;`python patterns.py` 运行自检,test_patterns.py 是测试。"""
|
||||
from __future__ import annotations
|
||||
|
||||
import heapq
|
||||
from collections import Counter, OrderedDict, deque
|
||||
from typing import Hashable, Iterable
|
||||
|
||||
|
||||
# 1. 哈希表:两数之和 O(n) / O(n)
|
||||
def two_sum(nums: list[int], target: int) -> tuple[int, int] | None:
|
||||
seen: dict[int, int] = {}
|
||||
for i, x in enumerate(nums):
|
||||
if target - x in seen:
|
||||
return seen[target - x], i
|
||||
seen[x] = i
|
||||
return None
|
||||
|
||||
|
||||
# 2. 滑动窗口:无重复字符的最长子串 O(n) / O(字符集)
|
||||
def longest_unique_substring(s: str) -> int:
|
||||
last: dict[str, int] = {}
|
||||
left = best = 0
|
||||
for right, ch in enumerate(s):
|
||||
if last.get(ch, -1) >= left:
|
||||
left = last[ch] + 1 # 窗口左边界跳到重复字符的下一位
|
||||
last[ch] = right
|
||||
best = max(best, right - left + 1)
|
||||
return best
|
||||
|
||||
|
||||
# 3. 二分查找:第一个 >= target 的位置(lower_bound) O(log n) / O(1)
|
||||
def lower_bound(arr: list[int], target: int) -> int:
|
||||
lo, hi = 0, len(arr) # 左闭右开区间 [lo, hi)
|
||||
while lo < hi:
|
||||
mid = (lo + hi) // 2
|
||||
if arr[mid] < target:
|
||||
lo = mid + 1
|
||||
else:
|
||||
hi = mid
|
||||
return lo
|
||||
|
||||
|
||||
# 4. 堆:出现次数最多的 K 个(例如热门问题) O(n log k) / O(n)
|
||||
def top_k_frequent(items: Iterable[Hashable], k: int) -> list[Hashable]:
|
||||
counts = Counter(items)
|
||||
return [x for _, x in heapq.nlargest(k, ((c, x) for x, c in counts.items()))]
|
||||
|
||||
|
||||
# 5. BFS:网格最短路径(0 可走,1 障碍) O(行×列) / O(行×列)
|
||||
def shortest_path(grid: list[list[int]], start: tuple[int, int], end: tuple[int, int]) -> int:
|
||||
rows, cols = len(grid), len(grid[0])
|
||||
q = deque([(start, 0)])
|
||||
seen = {start}
|
||||
while q:
|
||||
(r, c), d = q.popleft()
|
||||
if (r, c) == end:
|
||||
return d
|
||||
for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):
|
||||
nr, nc = r + dr, c + dc
|
||||
if 0 <= nr < rows and 0 <= nc < cols and grid[nr][nc] == 0 and (nr, nc) not in seen:
|
||||
seen.add((nr, nc))
|
||||
q.append(((nr, nc), d + 1))
|
||||
return -1
|
||||
|
||||
|
||||
# 6. DFS + 拓扑排序:任务依赖的执行顺序(有环返回 None) O(V+E)
|
||||
def topo_order(deps: dict[str, list[str]]) -> list[str] | None:
|
||||
"""deps[a] = [b, c] 表示 a 依赖 b 和 c(b、c 要先执行)。"""
|
||||
state: dict[str, int] = {} # 0/缺省 未访问,1 访问中,2 已完成
|
||||
order: list[str] = []
|
||||
|
||||
def visit(n: str) -> bool:
|
||||
if state.get(n) == 1:
|
||||
return False # 回到“访问中”的节点:有环
|
||||
if state.get(n) == 2:
|
||||
return True
|
||||
state[n] = 1
|
||||
for m in deps.get(n, []):
|
||||
if not visit(m):
|
||||
return False
|
||||
state[n] = 2
|
||||
order.append(n)
|
||||
return True
|
||||
|
||||
nodes = set(deps) | {m for ms in deps.values() for m in ms}
|
||||
for n in sorted(nodes):
|
||||
if not visit(n):
|
||||
return None
|
||||
return order
|
||||
|
||||
|
||||
# 7. 动态规划:编辑距离(文本相似度、纠错) O(mn) / O(n)
|
||||
def edit_distance(a: str, b: str) -> int:
|
||||
prev = list(range(len(b) + 1))
|
||||
for i in range(1, len(a) + 1):
|
||||
cur = [i] + [0] * len(b)
|
||||
for j in range(1, len(b) + 1):
|
||||
cur[j] = prev[j - 1] if a[i - 1] == b[j - 1] else 1 + min(prev[j - 1], prev[j], cur[j - 1])
|
||||
prev = cur
|
||||
return prev[-1]
|
||||
|
||||
|
||||
# 8. 设计题:LRU 缓存 get/put 均为 O(1)
|
||||
class LRUCache:
|
||||
def __init__(self, capacity: int):
|
||||
self.capacity = capacity
|
||||
self.data: OrderedDict[Hashable, object] = OrderedDict()
|
||||
|
||||
def get(self, key: Hashable) -> object | None:
|
||||
if key not in self.data:
|
||||
return None
|
||||
self.data.move_to_end(key) # 最近使用的移到末尾
|
||||
return self.data[key]
|
||||
|
||||
def put(self, key: Hashable, value: object) -> None:
|
||||
self.data[key] = value
|
||||
self.data.move_to_end(key)
|
||||
if len(self.data) > self.capacity:
|
||||
self.data.popitem(last=False) # 淘汰最久未使用的(头部)
|
||||
|
||||
|
||||
# 9. 区间合并:合并重叠的时间段(排班、会议室) O(n log n)
|
||||
def merge_intervals(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]:
|
||||
out: list[tuple[int, int]] = []
|
||||
for s, e in sorted(intervals):
|
||||
if out and s <= out[-1][1]:
|
||||
out[-1] = (out[-1][0], max(out[-1][1], e))
|
||||
else:
|
||||
out.append((s, e))
|
||||
return out
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
assert two_sum([2, 7, 11, 15], 9) == (0, 1)
|
||||
assert longest_unique_substring("abcabcbb") == 3
|
||||
assert lower_bound([1, 3, 3, 5], 3) == 1
|
||||
assert top_k_frequent(["退货", "发票", "退货", "物流", "退货", "物流"], 2) == ["退货", "物流"]
|
||||
assert shortest_path([[0, 0, 0], [1, 1, 0], [0, 0, 0]], (0, 0), (2, 0)) == 6
|
||||
assert topo_order({"deploy": ["test"], "test": ["build"]}) == ["build", "test", "deploy"]
|
||||
assert edit_distance("kitten", "sitting") == 3
|
||||
assert merge_intervals([(1, 3), (2, 6), (8, 10)]) == [(1, 6), (8, 10)]
|
||||
print("全部自检通过")
|
||||
@@ -0,0 +1,63 @@
|
||||
import random
|
||||
|
||||
import pytest
|
||||
|
||||
from patterns import (LRUCache, edit_distance, longest_unique_substring, lower_bound, merge_intervals,
|
||||
shortest_path, top_k_frequent, topo_order, two_sum)
|
||||
|
||||
|
||||
def test_two_sum():
|
||||
assert two_sum([3, 3], 6) == (0, 1)
|
||||
assert two_sum([1, 2], 10) is None
|
||||
|
||||
|
||||
@pytest.mark.parametrize("s,n", [("", 0), ("bbbb", 1), ("pwwkew", 3), ("abba", 2), ("你好你们好", 3)])
|
||||
def test_longest_unique(s, n):
|
||||
assert longest_unique_substring(s) == n
|
||||
|
||||
|
||||
def test_lower_bound_matches_bisect():
|
||||
import bisect
|
||||
rng = random.Random(0)
|
||||
for _ in range(200): # 与标准库对拍
|
||||
arr = sorted(rng.randint(0, 20) for _ in range(rng.randint(0, 15)))
|
||||
t = rng.randint(-1, 21)
|
||||
assert lower_bound(arr, t) == bisect.bisect_left(arr, t)
|
||||
|
||||
|
||||
def test_top_k():
|
||||
assert top_k_frequent([], 3) == []
|
||||
assert top_k_frequent(list("aaabbc"), 1) == ["a"]
|
||||
|
||||
|
||||
def test_shortest_path_blocked():
|
||||
assert shortest_path([[0, 1], [1, 0]], (0, 0), (1, 1)) == -1
|
||||
assert shortest_path([[0]], (0, 0), (0, 0)) == 0
|
||||
|
||||
|
||||
def test_topo_cycle_and_order():
|
||||
assert topo_order({"a": ["b"], "b": ["a"]}) is None
|
||||
order = topo_order({"app": ["db", "cache"], "cache": ["net"], "db": ["net"]})
|
||||
assert order is not None
|
||||
pos = {n: i for i, n in enumerate(order)}
|
||||
assert pos["net"] < pos["db"] < pos["app"] and pos["net"] < pos["cache"] < pos["app"]
|
||||
|
||||
|
||||
def test_edit_distance():
|
||||
assert edit_distance("", "abc") == 3
|
||||
assert edit_distance("退货申请", "退款申请") == 1
|
||||
|
||||
|
||||
def test_lru():
|
||||
c = LRUCache(2)
|
||||
c.put("a", 1)
|
||||
c.put("b", 2)
|
||||
assert c.get("a") == 1 # a 变成最近使用
|
||||
c.put("c", 3) # 淘汰 b
|
||||
assert c.get("b") is None and c.get("a") == 1 and c.get("c") == 3
|
||||
|
||||
|
||||
def test_merge_intervals():
|
||||
assert merge_intervals([]) == []
|
||||
assert merge_intervals([(1, 4), (4, 5)]) == [(1, 5)]
|
||||
assert merge_intervals([(5, 6), (1, 2)]) == [(1, 2), (5, 6)]
|
||||
@@ -4,12 +4,32 @@ title: 数据结构与算法(面试)
|
||||
type: index
|
||||
domain: cs
|
||||
stack: [algorithms]
|
||||
tags: []
|
||||
tags: [算法, 数据结构, 复杂度, 手写代码]
|
||||
week: [16]
|
||||
---
|
||||
|
||||
# 数据结构与算法(面试)
|
||||
|
||||
常考数据结构、复杂度、双指针、哈希、二分、BFS/DFS、动态规划入门。
|
||||
掌握九个高频模式、能讲复杂度、写出无 bug 的中等题。BOSS直聘 2026-10-23 的调研中有岗位提到算法 / 数据结构基础。
|
||||
|
||||
> 本专题建设中:课程、企业场景、面试题和示例代码会陆续补充。
|
||||
## 学习路线
|
||||
|
||||
| 顺序 | 课程 | 级别 | 预计 |
|
||||
| --- | --- | --- | --- |
|
||||
| 1 | [复杂度分析和九个高频模式:哈希、滑动窗口、二分、堆、BFS、拓扑排序、动态规划、LRU、区间合并](01-complexity-patterns.md) | 基础 | 6 小时 |
|
||||
|
||||
## 企业场景
|
||||
|
||||
- [业务中的算法:热门问题 Top K、任务依赖排序、相似问题去重和缓存淘汰](scenarios/business-algorithms.md)
|
||||
|
||||
## 面试题
|
||||
|
||||
- [数据结构与算法面试题](interview.md)
|
||||
|
||||
## 示例代码
|
||||
|
||||
- [examples/patterns](examples/patterns/):9 个模式的实现和 13 个测试(只用标准库)
|
||||
|
||||
## 在 16 周计划中
|
||||
|
||||
- [第 16 周:面试冲刺](../../../plan/week16-interview.md)
|
||||
@@ -0,0 +1,67 @@
|
||||
---
|
||||
id: cs.algorithms.interview
|
||||
title: 数据结构与算法面试题
|
||||
type: interview
|
||||
domain: cs
|
||||
stack: [algorithms]
|
||||
tags: [算法, 数据结构, 手写代码, 面试]
|
||||
level: basic
|
||||
related: [cs.algorithms.complexity-patterns]
|
||||
week: [16]
|
||||
---
|
||||
|
||||
# 数据结构与算法面试题
|
||||
|
||||
## 基础
|
||||
|
||||
### 【基础】哈希表的原理是什么?冲突怎么处理?
|
||||
|
||||
**参考答案**:通过哈希函数把键映射到数组下标,平均 O(1) 查找。冲突处理:链地址法(同一位置挂链表 / 树)、开放寻址法(探测下一个空位)。负载因子过高时扩容并重新哈希。
|
||||
|
||||
**追问**:Python 的 dict 用哪种?→ 开放寻址;从 3.7 起保证插入顺序。
|
||||
|
||||
### 【基础】手写二分查找,找第一个大于等于 target 的位置。
|
||||
|
||||
**参考答案**:左闭右开 `[lo, hi)`,`arr[mid] < target` 时 `lo = mid + 1`,否则 `hi = mid`,循环条件 `lo < hi`,返回 `lo`。见[示例](examples/patterns/patterns.py)。
|
||||
|
||||
**追问**:怎么找最后一个等于 target 的位置?→ 找第一个大于 target 的位置再减 1,并检查该位置的值是否等于 target。
|
||||
|
||||
### 【基础】数组和链表的区别?
|
||||
|
||||
**参考答案**:数组连续存储,随机访问 O(1),中间插入删除 O(n),缓存友好;链表随机访问 O(n),已知节点时插入删除 O(1),额外的指针开销。
|
||||
|
||||
**追问**:LRU 为什么用哈希表 + 双向链表?→ 哈希表 O(1) 定位节点,双向链表 O(1) 移动和删除节点。
|
||||
|
||||
## 进阶
|
||||
|
||||
### 【进阶】实现 LRU 缓存,get 和 put 都是 O(1)。
|
||||
|
||||
**参考答案**:哈希表存键到节点的映射,双向链表维护使用顺序:访问时移到尾部,超容量时删除头部。Python 可用 `OrderedDict.move_to_end` 和 `popitem(last=False)`。
|
||||
|
||||
**追问**:多线程下怎么办?→ 加锁,或分段锁降低竞争;如果是分布式缓存,用 Redis 的淘汰策略(`allkeys-lru`)。
|
||||
|
||||
### 【进阶】如何从海量数据中找出出现次数最多的 K 个?
|
||||
|
||||
**参考答案**:哈希计数 + 大小为 K 的小顶堆,O(n log K)。数据放不进内存时:按哈希分片写入多个文件,分别统计 Top K,再合并。
|
||||
|
||||
**追问**:可以接受误差时?→ Count-Min Sketch 等近似计数结构,内存固定。
|
||||
|
||||
### 【进阶】怎么判断任务依赖中是否有环?
|
||||
|
||||
**参考答案**:DFS 三色标记(未访问、访问中、已完成),遇到“访问中”的节点说明有环;或者 Kahn 算法:不断移除入度为 0 的节点,最后仍有节点未移除说明有环。
|
||||
|
||||
**追问**:哪些业务会用到?→ 构建系统、CI 流水线、工作流引擎、数据管道调度。
|
||||
|
||||
## 场景题
|
||||
|
||||
### 【场景题】现场手写:无重复字符的最长子串。
|
||||
|
||||
**参考答案**:滑动窗口,记录每个字符最后出现的位置;遇到重复且在窗口内时,左边界移到重复位置的下一位;每步更新最大长度。O(n)。注意 "abba" 这类重复字符已在窗口外的情况。
|
||||
|
||||
**追问**:如果允许最多 K 个不同字符?→ 窗口内用哈希表计数,不同字符数超过 K 时收缩左边界。
|
||||
|
||||
### 【场景题】运营后台要显示每小时的热门问题 Top 20,怎么做?
|
||||
|
||||
**参考答案**:规范化文本 → 哈希计数 → 堆取 Top K;多实例用 Redis 有序集合按小时分 key 累加并设置过期;语义相近的问题再做聚类合并。详见[业务中的算法](scenarios/business-algorithms.md)。
|
||||
|
||||
**追问**:复杂度是多少?→ 计数 O(n),取 Top K 为 O(m log K),m 是不同问题的数量。
|
||||
@@ -0,0 +1,73 @@
|
||||
---
|
||||
id: cs.algorithms.scenario.business-algorithms
|
||||
title: 业务中的算法:热门问题 Top K、任务依赖排序、相似问题去重和缓存淘汰
|
||||
type: scenario
|
||||
domain: cs
|
||||
stack: [algorithms, redis, langgraph]
|
||||
tags: [Top K, 拓扑排序, 编辑距离, LRU, 去重, 复杂度]
|
||||
level: intermediate
|
||||
prerequisites: [cs.algorithms.complexity-patterns]
|
||||
est_hours: 1.5
|
||||
related: [cs.algorithms.interview]
|
||||
week: [16]
|
||||
---
|
||||
|
||||
# 业务中的算法:热门问题 Top K、任务依赖排序、相似问题去重和缓存淘汰
|
||||
|
||||
## 业务背景与问题
|
||||
|
||||
AI 客服运营后台需要:
|
||||
|
||||
1. 每小时展示用户最常问的 20 个问题(每小时几十万条消息);
|
||||
2. 知识库导入任务有依赖(先解析、再分块、再嵌入、再建索引),要按正确顺序执行,并发现配置中的循环依赖;
|
||||
3. 标注 Bad Case 时,大量问题只是错别字或说法略有不同,需要聚合去重;
|
||||
4. 进程内缓存最近查询的文档,内存有限。
|
||||
|
||||
## 约束
|
||||
|
||||
- 统计要在秒级完成。
|
||||
- 去重不能误合并意思不同的问题。
|
||||
|
||||
## 方案设计
|
||||
|
||||
1. **Top K**:先对问题文本做规范化(去空白、统一全半角),用哈希表计数,再用大小为 K 的堆取前 K,O(n log K);多实例时用 Redis 有序集合 `ZINCRBY` + `ZREVRANGE` 汇总。
|
||||
2. **任务依赖**:用拓扑排序得到执行顺序,检测到环时拒绝保存配置;同层没有依赖关系的任务可以并行。
|
||||
3. **相似去重**:先按规范化文本精确去重;再对候选对计算编辑距离(短文本)或向量相似度(语义),超过阈值的合并为一组,人工确认后生效。编辑距离是 O(mn),只对长度相近的候选对计算,避免 O(n²) 两两比较全部。
|
||||
4. **缓存**:LRU 淘汰;Python 中可直接用 `functools.lru_cache` 或 `OrderedDict` 实现。
|
||||
|
||||
## 关键代码
|
||||
|
||||
```python
|
||||
from patterns import edit_distance, top_k_frequent, topo_order
|
||||
|
||||
hot = top_k_frequent((normalize(m.text) for m in messages), 20)
|
||||
|
||||
order = topo_order({"index": ["embed"], "embed": ["chunk"], "chunk": ["parse"]})
|
||||
if order is None:
|
||||
raise ValueError("任务配置存在循环依赖")
|
||||
|
||||
def similar(a: str, b: str) -> bool:
|
||||
if abs(len(a) - len(b)) > 2: # 先用长度剪枝
|
||||
return False
|
||||
return edit_distance(a, b) <= max(1, len(a) // 10)
|
||||
```
|
||||
|
||||
完整实现和测试:[examples/patterns](../examples/patterns/)。
|
||||
|
||||
## 取舍
|
||||
|
||||
| 选择 | 优点 | 缺点 |
|
||||
| --- | --- | --- |
|
||||
| **精确计数 + 堆(本方案)** | 结果准确 | 内存随不同问题数增长 |
|
||||
| 近似算法(Count-Min Sketch 等) | 内存固定 | 有误差 |
|
||||
| 编辑距离去重 | 适合错别字 | 识别不了同义改写,需要配合向量相似度 |
|
||||
|
||||
## 易错点
|
||||
|
||||
- 没有规范化就计数,同一问题被拆成多个。
|
||||
- 对全部问题两两计算相似度,O(n²) 跑不完。
|
||||
- 去重阈值过松,把“退货”和“退款”合并(它们的编辑距离只有 1,但业务含义不同)——相似度只是候选,需要人工确认或结合业务规则。
|
||||
|
||||
## 面试怎么讲
|
||||
|
||||
> “运营后台的热门问题,我先做文本规范化,用哈希表计数加大小为 K 的堆取 Top K,复杂度 O(n log K),多实例用 Redis 有序集合汇总。导入任务的依赖用拓扑排序确定顺序并检测环。Bad Case 去重先精确去重,再按长度剪枝后算编辑距离,阈值只产生候选,避免把‘退货’和‘退款’这种只差一个字但意思不同的问题合并。”
|
||||
Reference in new issue
Block a user