目前主要内容包括：

• COMP4133AADS 课程复习资料、练习题和期末模拟题。
• SceneShift Discussion Room 与其他 XR / MR / Unity 项目的公开入口。
• GitHub 项目、Bilibili、小红书和 Arcaea 腾讯频道等公开链接。
• 宁诺相关 Bus 工具，以及后续可能加入的学习和开发小工具。

后续这个页面会作为站点更新记录的一部分，用来记录比较重要的内容调整和功能优化。

使用方式：

• 先看每题的“模板速写区”（背下来）
• 再做“仿真题”限时（建议每题 25 分钟）
• 对照标准答案，检查：步骤是否完整、表格是否写清、复杂度是否给对。
• 无计算器训练：所有数字都选为手算友好。

Question 1 (25 marks) — Big-O + Hash Tables / Map ADT

A. 模板速写区（考前 60 秒）

• Big-O 定义：存在 Mikusc COMP4133AADS 期末复习 模拟卷 Thu, 08 Jan 2026 11:30:00 GMT COMP4133AADS 期末模拟卷（4 题必做）— 含模板与标准答案

  使用方式：

  • 先看每题的“模板速写区”（背下来）
  • 再做“仿真题”限时（建议每题 25 分钟）
  • 对照标准答案，检查：步骤是否完整、表格是否写清、复杂度是否给对。
  • 无计算器训练：所有数字都选为手算友好。

  ---

  Question 1 (25 marks) — Big-O + Hash Tables / Map ADT

  A. 模板速写区（考前 60 秒）

  • Big-O 定义：存在 $c>0,n_0$ 使 $f(n)\le c g(n)$ 对所有 $n\ge n_0$ 成立
  • 计数循环：写 $T(n)$（可用求和），再化简成 $O(\cdot)$
  • Hash：$\alpha=n/N$；冲突处理三种：chaining / linear probing / double hashing
  • Linear probing：$h(k),h(k)+1,\dots$
  • Double hashing：$h(k)+i h_2(k)\pmod N$
  • 平均 vs 最坏：平均常写 $O(1)$（依赖 $\alpha$），最坏 $O(n)$

  ---

  B. 仿真题（25 marks）

  (1) Big-O 证明（6 marks）

  证明 $f(n)=2n+10$ 是 $O(n)$，给出一组可行的 $c$ 与 $n_0$。

  标准答案（示例写法）
  当 $n\ge 10$，有 $10\le n$，因此

  $$2n+10\le 2n+n=3n$$

  取 $c=3,n_0=10$，则对所有 $n\ge 10$，$f(n)\le c\,n$ 成立，所以 $2n+10=O(n)$。

  ---

  (2) Primitive operations / 循环复杂度（6 marks）

  考虑伪代码：

  1 2 3 4 5 6

  count = 0 for i = 1..n: j = 1 while j <= n: count++ j = 2*j

  1. 写出 while 循环执行次数（用 $\log_2 n$ 表示）
  2. 写出总复杂度 Big-O

  标准答案

  • while 中 $j$ 每次翻倍：$1,2,4,\dots$，执行次数为 $\lfloor \log_2 n \rfloor+1$
  • 外层 for 执行 $n$ 次，所以总次数：

  $$T(n)=n(\lfloor \log_2 n \rfloor+1)=O(n\log n)$$

  ---

  (3) Hash table（Linear probing）（7 marks）

  表大小 $N=11$，哈希函数 $h(k)=k\bmod 11$。按顺序插入 keys：

  $$[21,\ 32,\ 43,\ 54,\ 65,\ 76]$$

  使用 linear probing，写出最终哈希表（下标 0…10）。

  标准答案（逐步）

  • 21→10 放 10
  • 32→10 冲突，探测 0 放 0
  • 43→10 冲突，10/0 占，探测 1 放 1
  • 54→10 冲突，探测 2 放 2
  • 65→10 冲突，探测 3 放 3
  • 76→10 冲突，探测 4 放 4

  最终表（未填处为空）：

  idx	0	1	2	3	4	5	6	7	8	9	10
  key	32	43	54	65	76						21

  ---

  (4) Hash table（Double hashing）（6 marks）

  同样 $N=11$、$h(k)=k\bmod 11$，二次哈希：

  $$h_2(k)=1+(k\bmod 5)$$

  插入 keys $[21,32,43,54,65,76]$，写出最终表。

  标准答案（关键步）
  先算 $h_2$：

  • 21: $1+(1)=2$
  • 32: $1+(2)=3$
  • 43: $1+(3)=4$
  • 54: $1+(4)=5$
  • 65: $1+(0)=1$
  • 76: $1+(1)=2$

  插入：

  • 21→10 放 10
  • 32→10 冲突，步长 3：探测 $(10+3)=2$ 放 2
  • 43→10 冲突，步长 4：探测 $(10+4)=3$ 放 3
  • 54→10 冲突，步长 5：探测 $(10+5)=4$ 放 4
  • 65→10 冲突，步长 1：探测 0 放 0
  • 76→10 冲突，步长 2：探测 1 放 1

  最终表：

  idx	0	1	2	3	4	5	6	7	8	9	10
  key	65	76	32	43	54						21

  ---

  Question 2 (25 marks) — BST + AVL (Rotations / Trinode restructuring)

  A. 模板速写区

  • BST 性质：left < node < right
  • BST delete 三种情况：0/1/2 个孩子；两孩子用 inorder successor（右子树最小）
  • AVL：$|h_L-h_R|\le 1$
  • 插入后：找第一个失衡点 $z$，取 $y$（更高子树根）、$x$（更高子树根），做 LL/RR/LR/RL
  • AVL 时间：$O(\log n)$

  ---

  B. 仿真题（25 marks）

  (1) BST 构建与查询（8 marks）

  按顺序插入 keys：

  $$[50,\ 30,\ 70,\ 20,\ 40,\ 60,\ 80]$$

  1. 画出 BST
  2. 查找 key=60 的访问路径（写出依次比较的节点）

  标准答案
  BST（ASCII）：

  1 2 3 4 5

  50 / \ 30 70 / \ / \ 20 40 60 80

  查找 60：50 → 70 → 60（找到）

  ---

  (2) BST 删除（两孩子）（7 marks）

  在上题 BST 中删除 key=30。

  1. 写出 inorder successor 是谁
  2. 画出删除后的 BST

  标准答案

  • key=30 的右子树最小节点是 40，因此 successor=40
  • 用 40 替换 30，再删除原来的 40（叶子）

  结果：

  1 2 3 4 5

  50 / \ 40 70 / / \ 20 60 80

  ---

  (3) AVL 插入与旋转（10 marks）

  从空 AVL 树开始插入：

  $$[30,\ 20,\ 10,\ 25,\ 27]$$

  要求：每次插入后如果需要重平衡，指出属于 LL/RR/LR/RL，并画出最终 AVL。

  标准答案（关键旋转点）

  • 插 30,20,10：在 30 处失衡（LL），右旋 30：

  1 2 3

  20 / \ 10 30

  • 插 25：成为 30 的左孩子（仍平衡）
  • 插 27：插到 25 右边，导致 30 处失衡（LR：z=30，y=25，x=27）
    • 先左旋 25，再右旋 30

  最终 AVL：

  1 2 3 4 5

  20 / \ 10 27 / \ 25 30

  ---

  Question 3 (25 marks) — Graph Algorithms (BFS/DFS/Topo/MST/Dijkstra)

  A. 模板速写区

  • 邻接表遍历复杂度：$O(|V|+|E|)$
  • BFS：Queue；DFS：Stack/递归
  • Topo sort：DAG；若输出 < |V| 则有环
  • Prim：每次选跨 cut 的最小边加入（无环）
  • Dijkstra：非负权；extract-min 后 dist 固定；维护 prev[] 可回溯路径

  ---

  B. 仿真题（25 marks）

  (1) BFS / DFS（10 marks）

  给无向图 $G$，顶点 $\{A,B,C,D,E,F\}$，边：

  $$\{(A,B),(A,C),(B,D),(B,E),(C,F),(E,F)\}$$

  邻居访问顺序按字母序。

  1. 从 A 开始的 BFS 访问顺序
  2. 从 A 开始的 DFS 访问顺序（递归 DFS）

  标准答案

  • BFS（层序）：A, B, C, D, E, F
    • A 入队；出 A 入 B,C；出 B 入 D,E；出 C 入 F；其余已发现
  • DFS（字母序递归）：A → B → D → (回) → E → F → C
    访问序列：A, B, D, E, F, C

  ---

  (2) Topological sort（5 marks）

  给有向图（DAG）顶点 $\{1,2,3,4,5\}$，边：

  $$1\to 2,\ 1\to 3,\ 3\to 4,\ 2\to 4,\ 4\to 5$$

  写出一个合法拓扑序。

  标准答案（举例即可）

  • 1, 2, 3, 4, 5
    或 1, 3, 2, 4, 5（都合法）

  ---

  (3) Prim 求 MST（5 marks）

  无向加权图顶点 $\{A,B,C,D\}$，边权：

  • AB=1, AC=4, AD=3, BC=2, BD=5, CD=6
    从 A 开始 Prim，写出选边顺序与总权重。

  标准答案

  • 初始 S={A}：选 AB=1
  • S={A,B}：候选 BC=2, AD=3, AC=4, BD=5 → 选 BC=2
  • S={A,B,C}：候选 AD=3, AC=4, BD=5, CD=6 → 选 AD=3
    MST 边：AB, BC, AD；总权重 $1+2+3=6$。

  ---

  (4) Dijkstra（5 marks）

  有向非负权图，顶点 $\{S,A,B,C,T\}$，边：

  • S→A:2, S→B:5
  • A→B:1, A→C:2
  • B→C:3, B→T:6
  • C→T:1
    从 S 做 Dijkstra，给出到 T 的最短距离与一条最短路径。

  标准答案

  • S→A=2
  • S→A→B=3（比 5 更小）
  • S→A→C=4
  • 到 T：S→A→C→T = 2+2+1 = 5
    最短距离 5；路径 S-A-C-T。

  ---

  Question 4 (25 marks) — Dynamic Programming + String Indexing (BM/KMP/Trie)

  A. 模板速写区

  • DP 三要素：子问题定义 + 最优子结构 + 重叠
  • DP 答题必须写：状态、递推、初始、顺序、答案位置（可回溯）
  • 0/1 Knapsack：

  $$dp[i][w]=\max(dp[i-1][w],\ dp[i-1][w-w_i]+v_i)$$

  • Matrix chain：

  $$m[i][j]=\min_{k}(m[i][k]+m[k+1][j]+p_{i-1}p_kp_j)$$

  • BM：last-occurrence 表；KMP：failure 表；Trie：standard/compressed/suffix（会画）

  ---

  B. 仿真题（25 marks）

  (1) 0/1 Knapsack（12 marks）

  容量 $W=7$，3 个物品（重量 $w_i$，价值 $v_i$）：

  • 物品1：$w_1=3,v_1=4$
  • 物品2：$w_2=4,v_2=5$
  • 物品3：$w_3=2,v_3=3$
  1. 写出 $dp[i][w]$ 含义
  2. 填出 $i=0..3$、$w=0..7$ 的 DP 表
  3. 写最优价值与选取的物品

  标准答案

  1. $dp[i][w]$：用前 $i$ 个物品、容量为 $w$ 的最大价值。
  2. 表（只给关键结果行，考试可画表格填满）：
  • $dp[0][w]=0$
  • $i=1$（物品1:3,4）：
    • $w<3$：0；$w\ge3$：4
  • $i=2$（物品2:4,5）：
    • $dp[2][4]=5$
    • $dp[2][7]=\max(dp[1][7]=4,\ dp[1][3]+5=9)=9$
  • $i=3$（物品3:2,3）：
    • $dp[3][7]=\max(dp[2][7]=9,\ dp[2][5]+3)$
      而 $dp[2][5]=5$，所以 $dp[3][7]=\max(9,8)=9$

  结论：最优价值 9。
  3) 回溯：来自 $dp[2][3]+5$，因此选物品2（4,5）和物品1（3,4），总重 7，总值 9。

  ---

  (2) Matrix Chain Product（8 marks）

  矩阵维度：$A_1(10\times 30)$，$A_2(30\times 5)$，$A_3(5\times 60)$。

  1. 计算最少标量乘法次数
  2. 给出最优括号化

  标准答案
  两种括号：

  • $(A_1A_2)A_3$：
    • $A_1A_2$：$10\cdot30\cdot5=1500$，结果 $10\times5$
    • 再乘 $A_3$：$10\cdot5\cdot60=3000$
    • 总 $4500$
  • $A_1(A_2A_3)$：
    • $A_2A_3$：$30\cdot5\cdot60=9000$，结果 $30\times60$
    • 再乘 $A_1$：$10\cdot30\cdot60=18000$
    • 总 $27000$

  最少次数：4500；最优括号：$(A_1A_2)A_3$。

  ---

  (3) KMP failure function + 一次匹配（5 marks）

  Pattern $P=\texttt{abbab}$

  1. 写出 failure function $f(k)$（$k=0..4$）
  2. Text $T=\texttt{abbaabbab}$ 中第一次出现的位置（起始下标）

  标准答案

  1. $P= a b b a b$：
     | k | 0 | 1 | 2 | 3 | 4 |
     |—:|—:|—:|—:|—:|—:|
     | f(k) | 0 | 0 | 0 | 1 | 2 |

  2. 在 $T$ 中第一次匹配起始下标为 4（$T[4..8]=\texttt{abbab}$）。

  ---

  附：评分提醒（写答案时最容易丢分的点）

  • Big-O 证明必须写出 $c,n_0$（只写“显然”容易扣分）
  • Hash / Prim / Dijkstra 必须写“步骤”（只写最终结果常拿不到满分）
  • BST/AVL 必须画出“前后结构”（旋转类型写明 LL/LR/RL/RR）
  • DP 必须写：状态含义 + 递推 + base cases（只写最终数字不够）
  • BM/KMP 必须给出表（last-occurrence 或 failure）

  ---

  ]]> https://www.mikusc.top/2026/01/08/comp4133aads-final-exam-master-review/ COMP4133AADS 期末复习总纲（以 Revision 大纲 + 练习题为主线）

  目标：把“会考什么”压成一份可直接背、可直接手算的清单。
  建议复习顺序：先刷练习 → 总结模板 → 无计算器限时手算。

  ---

  0. 考试形式与复习原则

  考试形式（你需要匹配的输出能力）

  • 四题全做（Answer all FOUR questions），总分 100。
  • No calculators（所有题都能手算）。
  • 每题常见结构：定义/解释（短答） + 手推/计算（主分） + 复杂度分析/理由（加分点）。

  复习原则（效率最高）

  1. 每个主题先做对应练习 m]]> Mikusc COMP4133AADS 期末复习 Thu, 08 Jan 2026 11:00:00 GMT COMP4133AADS 期末复习总纲（以 Revision 大纲 + 练习题为主线）

     目标：把“会考什么”压成一份可直接背、可直接手算的清单。
     建议复习顺序：先刷练习 → 总结模板 → 无计算器限时手算。

     ---

     0. 考试形式与复习原则

     考试形式（你需要匹配的输出能力）

     • 四题全做（Answer all FOUR questions），总分 100。
     • No calculators（所有题都能手算）。
     • 每题常见结构：定义/解释（短答） + 手推/计算（主分） + 复杂度分析/理由（加分点）。

     复习原则（效率最高）

     1. 每个主题先做对应练习 md（不会就回看讲义/笔记）。
     2. 每个主题写一张“模板卡片”（伪代码 + 关键公式 + 复杂度 + 常见坑）。
     3. 最后做“手算训练”：哈希表插入、旋转、BFS/DFS 顺序、Prim/Dijkstra 表、DP 表、BM/KMP 表、Trie 结构。

     ---

     1. Big-O 与 Primitive Operations（基础必考）

     1.1 Big-O 定义（必须会写）

     $f(n)$ 是 $O(g(n))$：存在常数 $c>0$ 与 $n_0\ge 1$，使得对所有 $n\ge n_0$，

     $$f(n)\le c\,g(n)$$

     典型题型

     • 证明题：如证明 $2n+10$ 是 $O(n)$。
     • 化简题：如 $an^2+bn+c$ 是 $O(n^2)$。
     • 比较增长率：$\log n \ll n \ll n\log n \ll n^2 \ll 2^n$。

     证明模板（手写通用）

     要证 $f(n)=O(g(n))$：

     1. 对 $n$ 足够大时给上界：$f(n)\le c g(n)$
     2. 指定 $c$ 和 $n_0$
     3. 写一句：因此对所有 $n\ge n_0$ 成立。

     ---

     1.2 Primitive Operations（会数操作 → 推复杂度）

     常见 primitive ops：赋值、引用、算术、比较、数组按下标访问、方法调用、返回等。

     典型题型

     • 给一段代码：数 primitive operations 得 $T(n)$ → 写 Big-O。
     • 常见套路：
       • 双层循环：$n^2$
       • 三层循环：$n^3$
       • 一层循环 + 内部常数：$n$
       • 循环边界是 $n/2$、$3n$：仍是 $O(n)$

     ---

     2. Maps 与 Hash Tables（Map ADT + 冲突处理必须会算）

     2.1 Map ADT（会解释 + 会复杂度）

     • 基本操作：get(k), put(k,v), remove(k) 等。
     • list-based map（线性表实现）：
       • get/put/remove 最坏 $O(n)$（线性查找）。

     2.2 Hash Table（会手算插入/查找）

     必会概念

     • 哈希函数：$h(k)\in\{0,\dots,N-1\}$
     • 冲突 collision：不同 key 映射到同一桶/槽
     • 装载因子：$\alpha=\frac{n}{N}$（越大越容易冲突）

     冲突处理（考试常考三件套）

     1. Separate Chaining（拉链法）
     • 桶里放链表/动态数组
     • 平均：$O(1+\alpha)$，最坏：$O(n)$
     2. Linear Probing（线性探测）
     • 探测序列：$h(k),h(k)+1,h(k)+2,\dots \pmod N$
     • 常考：逐步填表、解释 clustering（主聚集）
     3. Double Hashing（双重散列）
     • 探测：$h(k)+i\cdot h_2(k)\pmod N$
     • 常考：给 $h,h_2$ 手算插入序列

     你要练到的程度（自测）

     • 给定 $N$、keys、hash 函数：写出每一次插入的探测过程 + 最终表格。
     • 给定一次 search：写出探测路径直到成功/失败。

     ---

     3. Sorted Map ADT 与 BST（定义 + 更新操作 + 复杂度）

     3.1 Sorted Map ADT（会说“按 key 有序”）

     典型操作（知道概念即可）：

     • first/last
     • floor/ceiling
     • lower/higher
       核心：依赖“有序结构”（BST/AVL）。

     3.2 BST 定义（必须背）

     • 左子树 key < 当前 key < 右子树 key（无重复时）。

     3.3 BST 基本操作（会画树 + 会删节点）

     • Search：沿左右走到底，时间 $O(h)$
     • Insert：找到外部节点插入，$O(h)$
     • Delete（最爱考）三种情况：
       1. 叶子：直接删
       2. 一个孩子：孩子替换
       3. 两个孩子：用 inorder successor（右子树最小）或 predecessor 替换，再删替换节点（最终落到 1/2）

     复杂度：

     • 最坏：退化成链 $h=n$ → $O(n)$
     • 一般写 $O(h)$ 即可。

     ---

     4. AVL（旋转/三节点重构是核心）

     4.1 AVL 定义（必须背）

     AVL 是 BST，且任意节点左右子树高度差不超过 1：

     $$|h(L)-h(R)|\le 1$$

     4.2 插入后的重平衡（会找 z-y-x）

     • 插入按 BST 做完
     • 向上找第一个失衡点 $z$
     • 令 $y$ 为 $z$ 的更高子树根，$x$ 为 $y$ 的更高子树根
     • 对 $(x,y,z)$ 做 trinode restructuring（对应 LL/RR/LR/RL）

     4.3 删除后的重平衡（会“aligned child”规则）

     • 删除后可能一路向上多次重平衡
     • 若 $y$ 两个孩子等高，选择与 $y$ 同侧 aligned 的孩子（避免错误结构）

     4.4 AVL 复杂度（必须会写）

     树高 $O(\log n)$，因此 search/insert/delete：

     $$O(\log n)$$

     ---

     5. Graph Algorithms（术语 + 表示 + BFS/DFS + Topo/MST/Dijkstra）

     5.1 术语（必背）

     vertex/edge、directed/undirected、weighted、path、cycle、connected、in-degree/out-degree

     5.2 图的表示（会对比）

     1. Adjacency Matrix：
     • 空间 $O(|V|^2)$，稀疏图浪费
     • 找邻居要扫整行
     2. Adjacency List：
     • 空间 $O(|V|+|E|)$
     • 稀疏图更好，遍历更高效

     5.3 BFS / DFS（会写伪代码 + 会给遍历序）

     • BFS：Queue，按层扩展
     • DFS：Stack/递归，尽可能深再回溯
       复杂度（邻接表）：

     $$O(|V|+|E|)$$

     常考：

     • 给图 + 起点：写 BFS/DFS 访问序（按题目规定的邻居顺序）
     • 用 BFS/DFS 判连通/找路径/判环（概念题）

     5.4 Topological Sort（DAG）

     • 关键：有环则无法拓扑排序
     • 常考：输出一个拓扑序或判断是否存在环

     5.5 MST 与 Prim（会手推每一步）

     • MST：权重总和最小的生成树
     • Prim：从任意点开始，每次选跨 cut 的最小边加入

     5.6 Dijkstra（非负权最短路）

     • 维护 dist[] + 优先队列
     • relax：若 $dist[v]>dist[u]+w(u,v)$ 则更新，并可维护 prev[] 输出路径
       复杂度（常用写法）：

     $$O((|V|+|E|)\log |V|)$$

     ---

     6. Dynamic Programming（DP）（定义三要素 + 经典题）

     6.1 DP 三要素（必背）

     1. Define subproblem（状态定义）
     2. Optimal substructure（最优子结构）
     3. Overlap（子问题重叠）

     6.2 DP 通用解题模板（考试通杀）

     必须写清楚：

     1. $dp[...]$ 含义
     2. 递推式
     3. base cases
     4. 计算顺序
     5. 返回值（答案在哪）
     6. 回溯（若要输出方案）

     6.3 经典题型（Revision 明确点名）

     (A) 1-D DP

     • 常见：Fibonacci、爬楼梯、最大子段和等
     • 形式多为：
       $dp[i]=\min/\max\{\dots\}$

     (B) Tri tiling

     • 常考：写递推或算前几项（若需要辅助状态要会解释“为什么必须扩展状态”）

     © 0/1 Knapsack（最爱考表格）

     • 状态：$dp[i][w]$ 表示前 $i$ 个物品、容量 $w$ 的最优值

     $$dp[i][w]=\max\big(dp[i-1][w],\ dp[i-1][w-w_i]+v_i\big)$$

     • 时间：$O(nW)$

     (D) Matrix Chain Product（最优括号）

     • $m[i][j]$：$A_i\cdots A_j$ 最少乘法次数

     $$m[i][j]=\min_{i\le k<j}\{m[i][k]+m[k+1][j]+p_{i-1}p_kp_j\}$$

     • 按链长递增计算

     6.4 练习中出现过的“图上 DP / 最短路 DP”（强烈建议掌握）

     • Backward（DAG 最短路）：

     $$V(t)=0,\quad V(i)=\min_{(i,j)\in E}\{c_{ij}+V(j)\}$$

     • Forward：

     $$F(s)=0,\quad F(j)=\min_{(i,j)\in E}\{F(i)+c_{ij}\}$$

     ---

     7. Pattern Matching（BF / BM / KMP：算表 + 手推过程）

     7.1 Brute Force

     最坏：

     $$O(nm)$$

     7.2 Boyer–Moore（BM）

     必会：

     1. last-occurrence function：$L(c)$ 为字符 $c$ 在 Pattern 中最右位置；无则 $-1$
     2. 手推 BM：右到左比较，mismatch 用 $L(c)$ 计算跳跃

     7.3 KMP

     必会：

     1. failure function（prefix function）：每个位置最长 proper prefix = suffix 长度
     2. 手推 KMP：mismatch 时 $k\leftarrow f(k-1)$ 复用比较结果
        复杂度：

     $$O(|T|+|P|)$$

     ---

     8. Trie（Standard / Compressed / Suffix Trie）

     8.1 为什么 Trie 快（会一句话解释）

     预索引文本/词典，前缀共享；查询长度 $m$ 通常：

     $$O(m)$$

     8.2 Standard Trie（会画）

     • 根无字符
     • 路径拼成词
     • 终止标记（terminal）

     8.3 Compressed Trie（会画）

     • 合并 single-child chain 为字符串边
     • 内部节点度数至少 2

     8.4 Suffix Trie（会构建思路）

     • 把文本所有后缀插入（常加 $）
     • substring 查询：沿模式串走路径，走完则存在，时间 $O(|P|)$

     ---

     9. 用“练习题 md”反向复习（最省时间）

     按考试覆盖面刷一遍（做完就能上考场）：

     • Lecture 2（Map & Hash Tables）：comp4133aads-lecture2-exercises.md
     • Lecture 3（BST / Sorted Map）：comp4133aads-lecture3-exercises.md
     • Lecture 4（AVL）：comp4133aads-lecture4-exercises.md
     • Week 6（Graph 1：ADT/表示/BFS/DFS）：comp4133aads-week6-graph-algorithms-1-exercises.md
     • Week 7（Graph 2：Topo/MST/Prim/Dijkstra）：comp4133aads-week7-graph-algorithms-2-exercises.md
     • Week 8（DP 1）：comp4133aads-week8-dp1-exercises.md
     • Week 9（DP 2）：comp4133aads-week9-dp2-exercises.md
     • Week 10（Pattern Matching）：comp4133aads-week10-pattern-matching-exercises.md
     • Week 11（Trie）：comp4133aads-week11-trie-exercises.md

     ---

     10. 最后一小时冲刺清单（Checklist）

     1. Big-O：能写定义 + 完成一次证明（如 $2n+10=O(n)$）
     2. 循环计数：能从代码数出 $T(n)$ 并给 Big-O
     3. Hash：能手推三种冲突处理填完整表
     4. BST：能画出 delete 三种情况（两孩子用 successor）
     5. AVL：能定位 z-y-x 并完成 LL/RR/LR/RL 重构；删除后会“aligned child”
     6. 图表示：能比较矩阵 vs 邻接表优缺点
     7. BFS/DFS：能给遍历序 + 写复杂度 $O(|V|+|E|)$
     8. Prim：能一步一步构 MST
     9. Dijkstra：能填 dist/prev 表并写出最终路径（非负权）
     10. BM/KMP/Trie：能“算表 + 手推过程 + 写复杂度”

     ---

     附：不需要花时间的部分

     • Optimization methods（优化方法）主要针对 project，不在考试范围（别再投入时间）。

     ---

     ]]> https://www.mikusc.top/2026/01/08/comp4133aads-lecture2-exercises/ Lecture 2 练习题复习（Maps & Hash Tables）— 含答案与思路

     本讲核心：Map ADT（接口与复杂度）+ Hash Table 实现（哈希函数设计、压缩函数、冲突处理：链地址 / 线性探测 / 双哈希）
     建议刷题顺序：Map 操作追踪 → 哈希函数思考题 → 线性探测（插入/查找/删除）→ 双哈希（为何要素数表长 + 计算探测序列）。

     ---

     练习 0：Map ADT 操作追踪（Lecture2 p7）

     题目（按顺序执行操作，填 Output，并写出每一步 Map 的内容）：

     ]]> MikuscCOMP4133AADS练习复习Thu, 08 Jan 2026 11:00:00 GMT Lecture 2 练习题复习（Maps & Hash Tables）— 含答案与思路

     本讲核心：Map ADT（接口与复杂度）+ Hash Table 实现（哈希函数设计、压缩函数、冲突处理：链地址 / 线性探测 / 双哈希）
     建议刷题顺序：Map 操作追踪 → 哈希函数思考题 → 线性探测（插入/查找/删除）→ 双哈希（为何要素数表长 + 计算探测序列）。

     ---

     练习 0：Map ADT 操作追踪（Lecture2 p7）

     题目（按顺序执行操作，填 Output，并写出每一步 Map 的内容）：

     Operation	Output	Map（key→value）

     Operation	Output	Map（key→value）
     isEmpty()
     put(5, A)
     put(7, B)
     put(2, C)
     put(8, D)
     put(2, E)
     get(7)
     get(4)
     get(2)
     size()
     remove(5)
     remove(2)
     get(2)
     isEmpty()

     解题思路（必背语义）

     • put(k,v)：
       • 若 k 不存在：插入并返回 null
       • 若 k 已存在：用新值替换旧值，返回旧值
     • get(k)：不存在返回 null
     • remove(k)：不存在返回 null；存在则删除并返回旧值
     • size()：当前 key 的个数（key 唯一）

     标准答案（逐步追踪）

     Operation	Output	Map（key→value）
     isEmpty()	true	{}
     put(5, A)	null	{5→A}
     put(7, B)	null	{5→A, 7→B}
     put(2, C)	null	{5→A, 7→B, 2→C}
     put(8, D)	null	{5→A, 7→B, 2→C, 8→D}
     put(2, E)	C	{5→A, 7→B, 2→E, 8→D}
     get(7)	B	{5→A, 7→B, 2→E, 8→D}
     get(4)	null	{5→A, 7→B, 2→E, 8→D}
     get(2)	E	{5→A, 7→B, 2→E, 8→D}
     size()	4	{5→A, 7→B, 2→E, 8→D}
     remove(5)	A	{7→B, 2→E, 8→D}
     remove(2)	E	{7→B, 8→D}
     get(2)	null	{7→B, 8→D}
     isEmpty()	false	{7→B, 8→D}

     ---

     思考题 1：为什么把 hash function 拆成 hash code + compression function？（Lecture2 p22）

     题目：
     What is the advantage of separating the hash function into two components, namely, hash code and compression function? Why?

     解题思路（抓住“职责分离 + 可复用”）

     把哈希拆成两段，本质是把 “把 key 变成整数” 和 “把整数变成表下标” 分开，方便复用/扩容/优化分布。

     参考答案（考试写 3~5 点）

     • 职责分离：h1（hash code）把任意类型 key 变成整数；h2（compression）把整数映射到 $[0, N-1]$。
     • 可复用性：同一个 h1 可以配不同表长 $N$ 的 h2；扩容/rehash 时主要调整 $N$ 与压缩。
     • 更易优化分布：针对 key 类型改 h1（如字符串多项式滚动），针对表长/范围改 h2（mod / MAD）。
     • 工程上更方便：很多语言对象自带 hashCode()（相当于 h1），你只需自定义压缩映射。

     ---

     思考题 2：为什么要“disperse”（分散）？为什么要“random”（看起来随机）？（Lecture2 p23）

     题目：

     • Why disperse?
     • Why random?

     解题思路

     哈希的目标不是“算得快”，而是“均匀”。分散与随机都是为了降低碰撞与聚集。

     参考答案

     • Why disperse?（为什么分散）
       让 key 尽量均匀落到 $N$ 个槽位，减少 collision → get/put/remove 的平均代价更接近 $O(1)$。
     • Why random?（为什么要看起来随机）
       防止 key 自身存在规律（例如等差、同前缀/后缀）导致某些槽位被集中命中，从而产生 clustering（探测代价变大）。

     ---

     自测 1：为什么 table size 选素数更好？（Lecture2 p27–28）

     题目：

     • hash codes 序列：$100, 105, 110, 115, \ldots$
     • 若 $N=10$（非素数）会发生什么？
     • 若 $N=11$（素数）会发生什么？
     • 用 $\gcd(N, d)$ 解释：什么时候能遍历所有槽位？什么时候只落在少数槽位？

     解题思路（等差数列 mod N）

     若 hash code 是等差序列 $a, a+d, a+2d, \ldots$，取模后能访问多少槽位，取决于 $\gcd(N, d)$：

     • 若 $\gcd(N, d)=1$ → 会遍历全部 $N$ 个槽位
     • 若 $\gcd(N, d)>1$ → 只会访问 $\frac{N}{\gcd(N,d)}$ 个槽位（其余槽位永远用不到）

     答案（用本题数据）

     • 这里步长 $d=5$。
     • $N=10$：$\gcd(10,5)=5$ → 只能访问 $10/5=2$ 个槽位。
       例如：$100 \bmod 10 = 0$，$105 \bmod 10 = 5$，$110 \bmod 10 = 0$……只在 $\{0,5\}$ 来回跳，大量槽位闲置，碰撞会很严重。
     • $N=11$：$\gcd(11,5)=1$（11 是素数，且 5 不整除 11）→ 能遍历全部 11 个槽位，分布通常更均匀。

     ---

     练习 1：线性探测（Linear Probing）插入（Lecture2 p31）

     题目：

     • $N = 13$
     • $h(x) = x \bmod 13$
     • 按顺序插入 keys：18, 41, 22, 44, 59, 32, 31, 73
     • 冲突处理：线性探测（冲突就 $(i+1) \bmod N$ 继续找空位）
     • 要求：画出最终 hash table（0…12），并写出每个 key 的 probe 序列或 probe 次数。

     解题思路（机械流程）

     对每个 key：

     1. 先算 $i = h(k)$
     2. 若槽空 → 放入
     3. 若槽占用 → $i = (i+1) \bmod 13$ 继续，直到找到空槽

     标准答案（最终表）

     索引 0..12：

     idx	0	1	2	3	4	5	6	7	8	9	10	11	12
     key			41			18	44	59	32	22	31	73

     各 key 的 probe 序列（写到落位即可）

     • 18：h=5 → [5]（放 5）
     • 41：h=2 → [2]（放 2）
     • 22：h=9 → [9]（放 9）
     • 44：h=5 冲突 → [5, 6]（放 6）
     • 59：h=7 → [7]（放 7）
     • 32：h=6 冲突 → [6, 7, 8]（放 8）
     • 31：h=5 连续冲突 → [5, 6, 7, 8, 9, 10]（放 10）
     • 73：h=8 冲突 → [8, 9, 10, 11]（放 11）

     记忆点：线性探测会形成连续“块”，越到后面 probe 越长 → primary clustering。

     ---

     练习 2：线性探测查找过程（Lecture2 p32–34）

     题目 A（概念题）：How to search with linear probing?
     题目 B（手算题）：在练习 1 的表里，追踪查找 key=32 的 probe 过程，写出访问下标序列。

     解题思路（查找规则）

     从 $i=h(k)$ 开始：

     • 若槽 空 → 直接失败（说明探测链断了）
     • 若槽 key 匹配 → 成功
     • 否则继续 $i=(i+1) \bmod N$
     • 最多 probe $N$ 次（防止死循环）

     标准答案（查找 32）

     • $h(32)=6$
     • 访问序列：6(44) → 7(59) → 8(32)
     • 所以 probe 序列是：[6, 7, 8]

     ---

     练习 3：线性探测删除（Lecture2 p35–36）

     题目：How do you remove an element x?

     解题思路（为什么不能直接置空）

     线性探测的查找依赖“探测链”。如果你把中间某格直接清空：

     • 查找遇到空槽会判定“失败”
     • 但其实后面可能还有通过探测放进去的元素
       → 会把后面的元素“找丢”

     标准答案（DEFUNCT / tombstone）

     • 删除时不要置空，而是标记为 DEFUNCT（墓碑）
     • get(k)：遇到 DEFUNCT 不能停，继续 probe；遇到真正空槽才停
     • put(k,v)：可以把 DEFUNCT 当作可插入位置（通常优先复用第一个遇到的 DEFUNCT）

     小例子（理解用）
     如果 44 在 idx=6，32 在 idx=8：

     • 直接把 idx=6 置空
     • 查找 32：从 6 开始，一看空槽就失败 → 错！
       所以必须用 DEFUNCT 维持探测链连续性。

     ---

     练习 4：双哈希（Double Hashing）为什么要求 N 为素数？（Lecture2 p38）

     题目：

     • probe 位置：$(h(k) + j\,d(k)) \bmod N$，$j=0,1,\ldots,N-1$
     • 例：$h(k)=1,\ d(k)=3$
       • 若 $N=12$，会访问哪些 positions？
       • 若 $N=13$，会访问哪些 positions？
     • 并解释为什么 $N$ 取素数更容易保证“覆盖全表”。

     解题思路（等差序列 mod N）

     探测序列是：$1, 1+3, 1+2\cdot 3, \ldots\ (\bmod\ N)$
     能覆盖多少槽位取决于 $\gcd(N, d)$：

     • $\gcd(N, d)=1$ → 覆盖全部 $N$ 个槽位
     • $\gcd(N, d)>1$ → 只覆盖 $\frac{N}{\gcd(N,d)}$ 个槽位，形成循环

     标准答案

     • $N = 12$：$\gcd(12,3)=3$ → 只覆盖 $12/3=4$ 个槽位
       探测：
       • j0: $(1+0) \bmod 12 = 1$
       • j1: $(1+3) \bmod 12 = 4$
       • j2: $(1+6) \bmod 12 = 7$
       • j3: $(1+9) \bmod 12 = 10$
       • j4: $(1+12) \bmod 12 = 1$（开始重复）
         所以 positions：$\{1,4,7,10\}$。
     • $N = 13$（素数）：$\gcd(13,3)=1$ → 覆盖全部 13 个槽位
       探测序列（按 j=0…12）：
       $1,4,7,10,0,3,6,9,12,2,5,8,11$（13 个都出现）

     结论：素数 $N$ 下，只要 $d(k)$ 不是 0 且不被 $N$ 整除，就更容易满足 $\gcd(N,d)=1$，从而探测覆盖全表。

     ---

     练习 5：双哈希插入整套演算（Lecture2 p39–40）

     题目：

     • $N = 13$
     • $h(k) = k \bmod 13$
     • $d(k) = 7 - (k \bmod 7)$
     • 按顺序插入 keys：18, 41, 22, 44, 59, 32, 31, 73
     • probe：$(h(k) + j\,d(k)) \bmod 13$，$j=0,1,2,\ldots$
     • 要求：画出最终表，并为每个 key 写出 probe 序列（至少写到落位为止）。

     解题思路（每个 key 都要算两件事）

     1. 算 $h(k)$
     2. 算 $d(k)$
     3. 从 $j=0$ 开始生成探测位置直到找到空槽

     标准答案（逐个 key）

     记号：$pos(j) = (h + j\,d) \bmod 13$

     1. 18
     • $h=18 \bmod 13=5$
     • $d=7-(18 \bmod 7)=3$
     • j0: pos=5 空 → 放 5
     • probe：$[5]$
     2. 41
     • $h=2$
     • $d=7-(41 \bmod 7)=1$
     • j0: 2 空 → 放 2
     • probe：$[2]$
     3. 22
     • $h=9$
     • $d=7-(22 \bmod 7)=6$
     • j0: 9 空 → 放 9
     • probe：$[9]$
     4. 44
     • $h=5$
     • $d=7-(44 \bmod 7)=5$
     • j0: 5 被 18 占 → j1: (5+5)=10 空 → 放 10
     • probe：$[5, 10]$
     5. 59
     • $h=7$
     • $d=7-(59 \bmod 7)=4$
     • j0: 7 空 → 放 7
     • probe：$[7]$
     6. 32
     • $h=6$
     • $d=7-(32 \bmod 7)=3$
     • j0: 6 空 → 放 6
     • probe：$[6]$
     7. 31
     • $h=5$
     • $d=7-(31 \bmod 7)=4$
     • j0: 5 被 18 占
     • j1: (5+4)=9 被 22 占
     • j2: (5+8)=13 mod13=0 空 → 放 0
     • probe：$[5, 9, 0]$
     8. 73
     • $h=8$
     • $d=7-(73 \bmod 7)=4$
     • j0: 8 空 → 放 8
     • probe：$[8]$

     最终 hash table（0…12）

     idx	0	1	2	3	4	5	6	7	8	9	10	11	12
     key	31		41			18	32	59	73	22	44

     复习要点（考试一句话总结）

     • 双哈希比线性探测更能“打散”探测路径，通常 clustering 更弱。
     • 要想探测覆盖全表，需要 $\gcd(N, d(k))=1$；取素数 $N$ 更容易满足。

     ---

     一页速记（考前 60 秒）

     • Map ADT：get/put/remove 语义要清楚（存在/不存在返回什么）。
     • List-based map：get/remove/put 最坏都 $O(n)$（因为要找 key）。
     • Hash table：期望 $O(1)$，最坏 $O(n)$（全碰撞）。
     • Hash function：$h(x)=h_2(h_1(x))$；目标：分散、看起来随机。
     • Compression：$\bmod\ N$ 常用；N 选素数通常更均匀。
     • Collision：
       • Chaining：简单，但额外内存。
       • Linear probing：primary clustering；删除要 DEFUNCT。
       • Double hashing：$(h + j\,d) \bmod N$；$d\ne 0$，$N$ 常取素数确保覆盖全表。
     ]]> https://www.mikusc.top/2026/01/08/comp4133aads-lecture4-exercises/ Lecture 4 练习题复习（AVL Trees）— 含答案与思路

     本讲核心：AVL 定义（高度平衡）+ rotation / trinode restructuring + 插入/删除后的 rebalance 规则 + 复杂度（高度 $O(\log n)$ Mikusc COMP4133AADS 练习复习 Thu, 08 Jan 2026 11:00:00 GMT Lecture 4 练习题复习（AVL Trees）— 含答案与思路

     本讲核心：AVL 定义（高度平衡）+ rotation / trinode restructuring + 插入/删除后的 rebalance 规则 + 复杂度（高度 $O(\log n)$）。
     课件来源：Lecture 4 AVLTrees_.pdf（Balanced Search Trees & AVL Trees）。

     ---

     练习 1：旋转（Rotation）的作用是什么？（p4–p6）

     题目（理解题）

     1. 什么是 rotation？
     2. rotation 为什么能在保持 BST 性质的同时改变形状？
     3. rotation 对子树 $T_1,T_2,T_3$ 中节点深度的影响是什么？

     解题思路

     • rotation 本质：把“孩子”提到“父亲”上面（局部重连指针）。
     • BST 性质依赖中序顺序不变；rotation 只在局部交换父子关系，并保持 $T_1 < X < T_2 < Y < T_3$ 的相对顺序。

     参考答案

     • rotation：将某节点的子节点上提为新的根（局部），原根下沉为其孩子。
     • 保持 BST：因为节点的中序（left-root-right）顺序不变，仍满足左小右大。
     • 深度变化：被“提上去”的节点深度减少 1；被“压下去”的节点深度增加 1；两侧子树（如 $T_1,T_3$）整体深度会相应 ±1（课件 p6 提示你观察变化）。

     ---

     练习 2：三节点重构 Trinode Restructuring 的算法理解（p7–p8）

     题目

     给定三代节点 $x$（孙）、$y$（父）、$z$（祖父），以及四棵子树 $T_1..T_4$。
     解释 restructure(x) 的关键步骤，并说明它等价于“单旋/双旋”。

     解题思路（抓住“排序 + 重新拼装”）

     • 把 $x,y,z$ 按 inorder 排序成 $(a,b,c)$（从小到大）。
     • 把四棵子树也按 inorder 顺序排成 $(T_1,T_2,T_3,T_4)$。
     • 让 b 做新的局部根，a 做左孩子（挂 $T_1,T_2$），c 做右孩子（挂 $T_3,T_4$）。

     参考答案（按课件算法写即可）

     • Step1：令 $(a,b,c)$ 为 $x,y,z$ 的 inorder 排序；令 $(T_1,T_2,T_3,T_4)$ 为四个子树的 inorder 排序。
     • Step2：用以 $b$ 为根的新子树替换原来以 $z$ 为根的子树。
     • Step3：令 $a$ 为 $b$ 的左孩子，并把 $T_1,T_2$ 挂到 $a$ 的左右。
     • Step4：令 $c$ 为 $b$ 的右孩子，并把 $T_3,T_4$ 挂到 $c$ 的左右。
     • 为什么等价于旋转：四种形态（LL/RR → 单旋；LR/RL → 双旋）都能用这一套“排序+拼装”统一处理。

     ---

     自学题 1：证明 AVL 树高度是 $O(\log n)$（p19 + p34）

     题目

     Proposition: The height of an AVL tree storing $n$ entries is $O(\log n)$.
     Self-study: How to prove it? Write down your proof.

     解题思路（最小节点数递推）

     设 $n(h)$ 为高度为 $h$ 的 AVL 树所需的最少内部节点数。
     AVL 的最“瘦”形态：一边高度 $h-1$，另一边高度 $h-2$。

     标准证明（写到这个程度就能拿分）

     • 基例：$n(1)=1,\; n(2)=2$。
     • 对 $h>2$：AVL 根的两棵子树高度分别至少为 $h-1$ 与 $h-2$，因此

       $$n(h)=1+n(h-1)+n(h-2).$$

     • 因为 $n(h-1) > n(h-2)$，有

       $$n(h)=1+n(h-1)+n(h-2) > 2n(h-2).$$

       迭代得到 $n(h) > 2^{i} n(h-2i)$。取 $i=\lfloor h/2 \rfloor - 1$ 回到基例，可得

       $$n(h) > 2^{h/2-1}.$$

     • 取对数：

       $$h < 2\log_2 n(h) + 2 \;\Rightarrow\; h = O(\log n).$$

     记忆点：AVL 的“最瘦”形态像 Fibonacci，所以高度是对数级。

     ---

     思考题 1：AVL 树的子树还是 AVL 吗？（p20）

     题目

     Is a subtree of an AVL tree an AVL tree?

     解题思路

     AVL 定义：对每个内部节点，高度差 $\le 1$。
     若从 AVL 树中取任意节点作为根的子树，这个子树里每个节点仍然满足同样的约束。

     标准答案

     ✅ 是。
     理由：AVL 的高度平衡性质对整棵树的每个内部节点都成立；子树只是其中一部分节点集合，约束仍对其内部所有节点成立。

     ---

     练习 3：AVL 插入后的 rebalance 规则（p22–p24）

     题目（流程题）

     插入一个新 key 后：

     1. 哪些节点的高度可能改变？
     2. 如何选择 $z,y,x$？
     3. 为什么只需要在 $z$ 处做一次 trinode restructuring 就能全局恢复平衡？

     解题思路（考试最常考的“套路”）

     • 只有从插入叶子 $p$ 到根的路径可能高度变化。
     • $z$：从 $p$ 往上遇到的第一个 unbalanced 节点。
     • $y$：$z$ 的更高的孩子；$x$：$y$ 的更高的孩子。
     • restructure(x) 之后，局部子树高度会恢复到插入前的高度（或不再增加），所以不会继续把失衡“传上去”。

     标准答案（写成要点即可）

     1. 可能改变的只有路径 $p \rightarrow \text{root}$ 上的祖先节点。
     2. $z$：路径上第一个失衡节点；$y$：$z$ 的高子树根；$x$：$y$ 的高子树根。
     3. restructure 在 $z$ 局部把三代节点重排，使得该局部重新满足高度平衡，并且该局部子树的高度不再导致更高祖先失衡，因此全局恢复（课件明确说该重构能“restore globally”）。

     ---

     练习 4：形式化论证插入过程正确性（p25）

     题目

     Exercise: Formally argue the correctness of the insertion process.

     解题思路（给你一个可直接背的“证明模板”）

     要证明“正确”，通常分两块：

     1. BST 性质保持（key 的相对大小不被破坏）
     2. AVL 平衡恢复（所有节点的高度差 $\le 1$）

     参考答案（考试可直接写）

     • BST 性质：插入阶段与普通 BST 插入相同（只在外部节点处扩展），不会破坏中序顺序；重平衡使用 rotation/trinode restructuring，而 restructuring 通过 inorder 排序 $(a,b,c)$ 与子树 $(T_1..T_4)$ 重新连接，保持 inorder 顺序不变，因此 BST 性质保持。
     • AVL 平衡：插入只可能使从新叶 $p$ 到根路径上的节点高度增加 1。令 $z$ 为该路径上第一个失衡节点，则 $z$ 的失衡形态必落在 $x,y,z$ 形成的 4 种局部结构之一。对 $z$ 执行 restructure(x) 后，局部恢复高度平衡；并且该局部子树的高度恢复为插入前的高度（或高度不再继续增加），因此不会导致更高祖先出现新的失衡。故一次重构即可恢复全局 AVL 性质。

     ---

     练习 5：AVL 删除后的 rebalance（含“aligned”规则）（p27–p30）

     题目

     删除后从节点 $w$（被结构删除节点的父亲）往上：

     1. 如何选择 $z,y,x$？
     2. 当 $y$ 的两个孩子高度相同，为什么要选择与 $y$ “aligned” 的那个孩子作为 $x$？
     3. 为什么删除可能需要一路检查到根？

     解题思路

     • 删除可能让某个子树高度减少，从而让祖先节点失衡；并且一次重构后，新的高度变化仍可能继续向上传播。
     • “aligned” 规则是为了避免选错 $x$ 造成局部重构后仍可能产生更糟的高度配置（课件 p29 用“problem”示意）。

     标准答案

     1. 令 $z$ 为从 $w$ 往上遇到的第一个失衡节点；$y$ 为 $z$ 的更高孩子；

     • 若 $y$ 的一个孩子更高：令 $x$ 为更高孩子；
     • 若两孩子等高：令 $x$ 为与 $y$ 同侧（aligned）的孩子（即 $y$ 是左孩子则选左；$y$ 是右孩子则选右）。

     2. aligned 的原因：当两边等高时，选择 aligned 能保证重构后高度变化符合 AVL 删除的正确性要求；若选不 aligned，可能得到课件 p29 圈出的“problem”形态（局部重构后导致不符合预期的高度/结构）。
     3. 删除可能让某次重构后子树高度继续减少，进而使更高祖先失衡，因此必须继续向上检查直到根（课件 p30–p31 明确写“must continue checking … until root”）。

     ---

     练习 6：AVL 性能总结（p33）

     题目（记忆题）

     写出 AVL 的空间与三种操作复杂度，并说明为什么。

     标准答案（按课件）

     • 空间：$O(n)$
     • 搜索：$O(\log n)$（高度 $O(\log n)$，无需重构）
     • 插入：$O(\log n)$：先查找插入位置 $O(\log n)$，之后最多一次重构 $O(1)$（维护高度也是 $O(1)$）
     • 删除：$O(\log n)$：先定位 $O(\log n)$，之后可能沿路径多次重构，总计 $O(\log n)$

     ---

     一页速记（考前 60 秒）

     • AVL 定义：任意节点左右子树高度差 $\le 1$。
     • 插入：找第一个失衡 $z$，取高孩子 $y$，再取高孩子 $x$，做 restructure(x)，通常只需一次。
     • 删除：从 $w$ 往上找失衡 $z$，同样选 $y,x$；若 $y$ 两边等高，选 aligned 的孩子；可能一路重构到根。
     • 高度证明：最小节点数递推 $n(h)=1+n(h-1)+n(h-2)\Rightarrow h=O(\log n)$。
     • 复杂度：search/insert/delete 都是 $O(\log n)$，空间 $O(n)$。

     ]]> https://www.mikusc.top/2026/01/08/comp4133aads-lecture3-exercises/ Lecture 3 练习题复习（Binary Search Trees）— 含答案与思路

     本讲核心：Sorted Map ADT（有序映射接口）+ BST（二叉搜索树）（性质、搜索、插入、删除）+ 为什么需要 Self-Balancing（为 AVL/红黑树做铺垫）。
     刷题建议：BST性质判断 → inorder遍历输出 → “为什么要平衡”与“如何重建平衡”。

     ---

     练习 1：判断是否是 BST（例题 A）（Slide 29）

     **题目：**Is this a binary search tree?

     给定树（关键节点）：

     COMP4133AADS 练习复习 Thu, 08 Jan 2026 11:00:00 GMT Lecture 3 练习题复习（Binary Search Trees）— 含答案与思路 本讲核心：Sorted Map ADT（有序映射接口）+ BST（二叉搜索树）（性质、搜索、插入、删除）+ 为什么需要 Self-Balancing（为 AVL/红黑树做铺垫）。 刷题建议：BST性质判断 → inorder遍历输出 → “为什么要平衡”与“如何重建平衡”。 练习 1：判断是否是 BST（例题 A）（Slide 29） **题目：**Is this a binary search tree? 给定树（关键节点）： 1 2 3 4 5 6 / \ 2 9 / \ / 1 4 8 解题思路（判 BST 的套路） BST 的全局约束不是“只看父子”，而是： 左子树所有 key < 根 key 右子树所有 key > 根 key 递归对每个子树都成立 标准答案 ✅ 是 BST。 理由： 左子树 {1,2,4} 都 < 6；右子树 {8,9} 都 > 6 在节点 2：左 1 < 2，右 4 > 2 在节点 9：左 8 < 9（且 8 > 6 也满足“在 6 的右子树”） 练习 2：判断是否是 BST（例题 B）（Slide 30） **题目：**Is this a binary search tree? 给定树（关键节点）： 1 2 3 4 5 6 / \ 2 9 / \ / 1 7 8 解题思路（抓“全局违规点”） 只要出现一个节点落在错误的祖先范围，就不是 BST。 例如：在根 6 的左子树中出现了 7（>6），就立刻违规。 标准答案 ❌ 不是 BST。 理由：节点 7 在 6 的左子树里，但 7 > 6，违反 BST 性质。 练习 3：Inorder Traversal 定义 + 输出（Slide 33） 题目： What is an inorder traversal of a tree? Exercise: what does an inorder traversal of the following search tree produce? 树与练习 1 的结构一致： 1 2 3 4 5 6 / \ 2 9 / \ / 1 4 8 解题思路 Inorder（中序）：Left → Visit → Right 对 BST 有一个关键性质： BST 的 inorder 输出一定是升序（in increasing order） 标准答案 inorder 定义：先访问左子树，再访问根，再访问右子树（Left-Root-Right）。 inorder 输出序列： $$1,\; 2,\; 4,\; 6,\; 8,\; 9$$ 思考题 1：很不平衡的 BST 是否总能对应一个平衡 BST？（Slide 44） 题目： Suppose you have a very imbalanced search tree. Is there always a corresponding balanced search tree? 解题思路 “对应”指的是：包含同一组 keys 的 BST。 BST 的形状不是唯一的：同一组 keys 可以对应很多不同结构的 BST。 标准答案 ✅ 总是存在。 理由：对任意一组 keys，把它们排序后，总能用“取中位数作根、递归构造左右子树”的方式构造出高度尽量小（接近平衡）的 BST。 练习 4：把给定的极度不平衡 BST 变成平衡 BST（Slide 44） **题目：**Exercise (online): find a balanced tree for（给定的树） 给定不平衡 BST（右斜）包含 keys：{3, 5, 7, 8, 9}。 解题思路（最常用：选中位数做根） 排序（本身已排序）：3, 5, 7, 8, 9 选中位数 7 做根 左边 {3,5} 构成左子树，右边 {8,9} 构成右子树 子问题继续选中位数 参考答案（满足 BST 且高度较小的一种） 1 2 3 4 5 7 / \ 5 8 / \ 3 9 说明：平衡树通常不唯一；只要保持 BST 性质并让高度明显降低即可。 思考题 2：为什么“任意节点数都能有平衡树”？如何从一棵树得到平衡树？（Slide 45） 题目： For any number of nodes, there is a balanced tree. Why? How to get a balanced tree given a binary tree? 解题思路 “平衡”本质是高度尽量小（接近 $\log n$） 构造法：按层填充或按中位数递归构造 参考答案（考试写法） Why（为什么总存在） 对任意 $n$，总能构造一个高度最小/接近平衡的二叉树形状（例如尽量按层填满）。 若是 BST：对 keys 排序后用“中位数递归”能得到高度 $O(\log n)$ 的 BST。 How（怎么从现有树得到平衡树）（常考“说流程”） 如果是 BST： inorder 遍历得到升序 keys（或 entries）列表（$O(n)$） 用“中位数递归”从有序列表直接构建平衡 BST（$O(n)$） 如果是一般二叉树（不要求 BST 性质）： 可以先收集所有节点，再按“尽量按层填满”的方式重连指针，得到更平衡的形状（核心思想同样是让高度变小）。 思考题 3：Total rebuild（整体重建）平衡 BST 的时间复杂度？（Slide 46） 题目： Could balance a tree by a “total rebuild” Just placing the keys into a new tree in the correct order What the time complexity of it? 解题思路（关键：你说清楚“怎么 rebuild”） 总复杂度 =（取出 keys）+（构建新树） 参考答案（两种常见口径，写一种并说明假设即可） 口径 A：直接从有序数组递归建树（推荐写法） inorder 得到有序 keys：$O(n)$ 递归“中位数建树”：每个节点建一次：$O(n)$ 总计：$O(n)$ 口径 B：用 insert 一个个插入到新 BST（要说明） 若每次插入都保持平衡（理想）：每次 $O(\log n)$，共 $n$ 次 → $O(n\log n)$ 若插入顺序不当（如升序插入）：会退化 → 最坏 $O(n^2)$ 考试最稳：写 $O(n)$（inorder + 递归建树），并补一句“如果用 repeated insert，则可能是 $O(n\log n)$”。 一页速记（考前 60 秒） BST 性质：左子树全小于根，右子树全大于根（是“全局范围约束”）。 inorder（左-根-右）：对 BST 输出一定是升序。 搜索/插入/删除：时间 $O(h)$，h 是树高；最坏退化链表 $h=n$。 平衡的意义：让 $h\approx \log n$，从而保证操作接近 $O(\log n)$。 “总重建”平衡：inorder 取出 keys + 中位数递归建树（通常 $O(n)$）。 ]]> https://www.mikusc.top/2026/01/08/comp4133aads-week10-pattern-matching-exercises/ Week 10 练习题复习（Pattern-Matching Algorithms）— 含答案与思路 来源：Week 10 PM.pdf。本文件只整理 PDF 里出现的练习题（Exercise）与思考题/提问，并给出标准解题思路与答案。 公式为 KaTeX：行内 $...$，独立 $$...$$。 思考题 A（Boyer–Moore 示例页）：Why BM is better than BF?（p9） 题目 Why BM is better than BF? 思路（抓住“跳跃”与“比较方向”） Mikusc COMP4133AADS 练习复习 Thu, 08 Jan 2026 11:00:00 GMT Week 10 练习题复习（Pattern-Matching Algorithms）— 含答案与思路 来源：Week 10 PM.pdf。本文件只整理 PDF 里出现的练习题（Exercise）与思考题/提问，并给出标准解题思路与答案。 公式为 KaTeX：行内 $...$，独立 $$...$$。 思考题 A（Boyer–Moore 示例页）：Why BM is better than BF?（p9） 题目 Why BM is better than BF? 思路（抓住“跳跃”与“比较方向”） BF（Brute Force）每次对齐通常只能右移 1 位，且从左到右比较，失败后大量比较被浪费。 BM 从右向左比较 + 用 bad-character（character-jump） 等启发式，失败时可以一次右移多位，从而显著减少对齐次数与比较次数（尤其在自然语言文本中）。 参考答案 Boyer–Moore 通常更快的原因： Right-to-left comparison：更容易在靠右位置早发现 mismatch。 Character-jump（bad-character）：mismatch 时按“最后出现位置”计算可跳过多次对齐。 在英文文本里字符分布不极端，BM 往往接近“亚线性”行为；而 BF 最坏仍是 $O(nm)$。 思考题 B（Boyer–Moore 示例页）：Why choose last occurrence?（p9） 题目 Why choose last occurrence? 思路 你要解释两点： 正确性（不会漏解）：对齐到“最后一次出现”仍保证所有可能匹配不会被跳过。 尽量大步跳（更快）：同一 mismatch 字符，用最右出现位置能给出最大安全位移。 参考答案 发生 mismatch：Text 当前字符为 $c$。 若 $c$ 在 Pattern 中出现过，把 Pattern 中 最右（last） 的 $c$ 与 Text 的该 $c$ 对齐；这样位移最大，同时不可能跳过一个潜在匹配（因为更右的 $c$ 才可能让 Pattern 仍覆盖当前 $c$）。 若 $c$ 不在 Pattern 中，则可以把 Pattern 整体移到 Text 当前字符右侧（Pattern[0] 对齐到 Text[i+1]），因为任何覆盖当前 $c$ 的对齐都不可能匹配。 思考题 C（Last-occurrence 页）：How to implement it using hash table?（p12） 题目 “Last-occurrence function can be computed in time $O(|P|)$ using hash table. How to implement it using hash table?” 思路 用 Map<Character, Integer>（Java：HashMap）存：字符 $o$ 最右索引。 扫一遍 Pattern，从左到右不断覆盖同一字符的值，最终留下最右索引。 对于 alphabet 里没出现的字符，默认值为 -1（可以 getOrDefault）。 参考答案（伪代码） 初始化 Map last = new HashMap<>() 对 Pattern 扫描： for i = 0..m-1: last.put(P[i], i) 查询： l = last.getOrDefault(c, -1) 时间：建立表 $O(|P|)$，查询均摊 $O(1)$。 Exercise 1：Last-occurrence function（p14） 题目 Find the last-occurrence function, given $S = \{a,b,c,d,r,s,t\}$ $P = \texttt{abstract}$ 请给出 $L(c)$（每个字符在 Pattern 中最右出现的位置；若不存在则为 $-1$）。 思路 把 Pattern 写上索引： abstract = a b s t r a c t 索引从 0 开始： a: 0,5 b: 1 s: 2 t: 3,7 r: 4 c: 6 d: 不出现 答案 char $c$ a b c d r s t $L(c)$ 5 1 6 -1 4 2 7 Exercise 2：Boyer–Moore algorithm（p18） 题目 Text（下标 0…9）： a b b a d b c a b b Pattern： c a b 用 Boyer–Moore（基于 last-occurrence 的 character-jump）求匹配位置（起始下标）。 准备：last-occurrence 表 Pattern c a b（索引 0…2）： $L(c)=0$，$L(a)=1$，$L(b)=2$，其他字符 $=-1$ 解题思路（按课件 BM 伪代码） 从右往左比较（先比 Pattern 最右字符 b） mismatch 时令 $l=L(T[i])$，更新： $$i \leftarrow i + m - \min(j, 1+l),\quad j\leftarrow m-1$$ 过程（关键步，够你复盘） $m=3$ 初始：$i=2, j=2$（Pattern 末尾对齐 Text[2]） 对齐起点 $s=i-(m-1)=0$： Text[2]=b 与 P[2]=b ✅ Text[1]=b 与 P[1]=a ❌（mismatch，$T[i]=T[1]=b$，$l=L(b)=2$） 更新：$i=1+3-\min(1,3)=1+3-1=3$，$j=2$ 对齐起点 $s=3-2=1$： Text[3]=a 与 P[2]=b ❌（$l=L(a)=1$） $i=3+3-\min(2,2)=4$，$j=2$ 对齐起点 $s=4-2=2$： Text[4]=d 与 P[2]=b ❌（$l=L(d)=-1$） $i=4+3-\min(2,0)=7$，$j=2$ 对齐起点 $s=7-2=5$： Text[7]=a 与 P[2]=b ❌（$l=L(a)=1$） $i=7+3-\min(2,2)=8$，$j=2$ 对齐起点 $s=8-2=6$： Text[8]=b 与 P[2]=b ✅ Text[7]=a 与 P[1]=a ✅ Text[6]=c 与 P[0]=c ✅ → 匹配成功 答案 匹配起始下标：6（Pattern 出现在 Text[6…8]）。 思考题 D（BM→KMP 过渡）：Can we pre-index mismatched Pattern characters in Pattern?（p23） 题目 “Pre-indexing mismatched Text characters in Pattern” 已有（BM 的 last-occurrence）。 Can we pre-indexing mismatched Pattern characters in Pattern? 参考答案 可以，这就是 KMP 的核心：预处理 Pattern 的 self-overlap（前后缀重叠），得到 failure function（或 prefix function）。 当 mismatch 发生时，不再把 Pattern 只右移 1 位，而是根据 failure function 直接跳到“仍可能匹配”的最长前缀位置，复用已成功比较的信息。 Exercise 3：KMP algorithm（p32） 题目 Text（下标 0…12）： a b b a a b b a a b b a b Pattern： a b b a b 要求： 计算 Pattern 的 failure function（课件记为 $f(k)$ 或数组 $F$） 用 KMP 找到 Pattern 在 Text 中的匹配起始位置（若有） (1) Failure function 思路（定义） $f(k)$：Pattern 的前缀中，既是 $P[0..k]$ 的后缀的最长长度（课件说明：$P[0]$ 不计入“零位移”，所以 $f(0)=0$）。 实操就是：对每个 $k$，找最长 proper prefix = suffix 的长度。 答案（Pattern = a b b a b） 索引 0…4： $k$ 0 1 2 3 4 $P[k]$ a b b a b $f(k)$ 0 0 0 1 2 解释要点： $k=3$（abba）有前后缀 a 重叠，长度 1 $k=4$（abbab）有前后缀 ab 重叠，长度 2 (2) KMP 匹配位置 思路（KMP 的“复用成功比较”） 维护 Text 指针 $j$、Pattern 指针 $k$ 若 mismatch 且 $k>0$：$k \leftarrow f(k-1)$（把 Pattern 右移到能复用的位置） 若 mismatch 且 $k=0$：$j++$ 答案 该 Pattern 在 Text 中匹配起始下标为：8（Text[8…12] = a b b a b）。 速记区（考试常问的点） BF：最坏时间 $O(nm)$ BM：预处理 last-occurrence（可用 HashMap，建表 $O(|P|)$）；平均快，但最坏仍可能 $O(nm)$ KMP：预处理 failure function $O(|P|)$，匹配 $O(|T|)$，总复杂度： $$O(|P|+|T|)$$ KMP 正确性/复杂度常用解释（课件）：定义 $s=j-k$，while 循环每轮至少让 $s$ 或 $j$ 增加 1，因此循环次数 $\le 2n$（$n=|T|$）。 ]]> https://www.mikusc.top/2026/01/08/comp4133aads-week11-trie-exercises/ Week 11 练习题复习（Trie）— 含答案与思路 资料来源：Week 11 Trie.pdf。本文件只整理 PDF 中出现的“问题标题（What/Why）”与 Exercise 1–3，并补全解题思路与标准答案。 KaTeX：行内 $...$、独立 $$...$$。 思考题 0：What is trie?（p3） 题目 What is trie? 思路 用一句“定义 + 用途”回答即可（课件强调 pre-indexing 与 fast pattern matching）。 参考答案 Trie（字典树/前缀树）是一]]> Mikusc COMP4133AADS 练习复习 Thu, 08 Jan 2026 11:00:00 GMT Week 11 练习题复习（Trie）— 含答案与思路 资料来源：Week 11 Trie.pdf。本文件只整理 PDF 中出现的“问题标题（What/Why）”与 Exercise 1–3，并补全解题思路与标准答案。 KaTeX：行内 $...$、独立 $$...$$。 思考题 0：What is trie?（p3） 题目 What is trie? 思路 用一句“定义 + 用途”回答即可（课件强调 pre-indexing 与 fast pattern matching）。 参考答案 Trie（字典树/前缀树）是一种树形数据结构，用来存储一组字符串（或一段文本中的所有单词），通过把公共前缀共享来支持： Pattern matching / word matching Prefix matching（前缀查询） 思考题 1：Why we need trie?（p4） 题目 Why we need trie? 思路 对比 Week10：BM/KMP 是“预处理 pattern”；Trie 是“预处理 text”。 参考答案 需要 Trie 的原因（课件要点）： 预处理（pre-indexing）可以加速匹配 BM：预处理 Pattern 得到 last-occurrence KMP：预处理 Pattern 得到 failure function Trie：预处理 Text（把文本中出现的所有单词建成 trie），从而加速 单词匹配（word matching） 前缀匹配（prefix search） 应用：information retrieval（信息检索） 练习 1：构建 Standard Trie（p7） 题目 Build the standard trie for: $$S=\{a,\; trie,\; is,\; tree,\; based,\; data,\; structure,\; for,\; storing,\; strings\}$$ 标准 trie 规则（课件 p5）： 根结点不带字符；其他节点带字符 children 按字母序（alphabetical order） 从根到叶（external node）的路径拼起来得到集合中的字符串 这里用 • 表示“单词结束（terminal）” 解题思路 先按首字母分组：a / b / d / f / i / s / t 同前缀共享：例如 storing/strings/structure 共享 st 每个单词末尾标记 •（否则 a 和 am... 这类会混淆） 参考答案（ASCII 标准 Trie） 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 (root) ├─ a • ├─ b │ └─ a └─ s └─ e └─ d • ├─ d │ └─ a └─ t └─ a • ├─ f │ └─ o └─ r • ├─ i │ └─ s • ├─ s │ └─ t │ ├─ o └─ r └─ i └─ n └─ g • (storing) │ └─ r │ ├─ i └─ n └─ g └─ s • (strings) │ └─ u └─ c └─ t └─ u └─ r └─ e • (structure) └─ t └─ r ├─ i └─ e • (trie) └─ e └─ e • (tree) 检查点： storing / strings / structure 的公共前缀是 st，再分叉 o... 与 r...。 trie / tree 的公共前缀是 tr，再分叉 i... 与 e...。 思考题 2：Standard trie 的复杂度（p8–p9） 题目 课件给出：标准 trie 空间 $O(n)$，操作时间 $O(dm)$。解释 $n,d,m$ 的含义，并说明如何把搜索优化到 $O(m)$。 参考答案 $n$：集合 $S$ 中所有字符串长度的总和（total size） $m$：要操作/查询的字符串参数长度 $d$：字母表大小（alphabet size） 标准 trie 每访问一个节点要找“下一个字符对应的孩子”： 若孩子用有序数组/列表存，可能要扫 $O(d)$ 若每个节点用二分/映射，能到 $O(\log d)$ 或 $O(1)$ 常见实现：每个节点维护 HashMap<char, child>，则搜索通常为： $$O(m)$$ 练习 2：构建 Compressed Trie（p12） 题目 Build the compressed trie for: $$S=\{a,\; trie,\; is,\; tree,\; based,\; data,\; structure,\; for,\; storing,\; strings\}$$ Compressed trie 定义（课件 p11）：把“只有一个孩子的内部节点”与孩子合并，使所有内部节点至少有两个孩子。边允许用字符串作为 label。 解题思路 先画出标准 trie（练习 1） 从根向下把所有“单链（single-child chain）”压缩成一条边 分叉点（degree ≥ 2）保留为节点 参考答案（ASCII 压缩 Trie） 1 2 3 4 5 6 7 8 9 10 11 12 13 14 (root) ├─ "a" • ├─ "based" • ├─ "data" • ├─ "for" • ├─ "is" • ├─ "st" (分叉点) │ ├─ "oring" • => storing │ └─ "r" (分叉点) │ ├─ "ings" • => strings │ └─ "ucture" • => structure └─ "tr" (分叉点) ├─ "ie" • => trie └─ "ee" • => tree 思考题 3：Word matching with a trie（p10） 题目 课件图示：把文本中的 words 插入 trie。每个 leaf 关联一个 word，并在 leaf 存该 word 在文本中出现的起始 index（例如 “see” 在 0 与 24 位置出现）。 为什么这样能支持快速 word matching？查询复杂度大概是多少？ 参考答案 因为 trie 共享前缀，查询一个长度为 $m$ 的单词只需沿边走（最多访问 $m+1$ 个节点） 若每个节点用 hash/map 找孩子，典型查询复杂度： $$O(m)$$ leaf 里存的 index 列表可以直接返回该单词所有出现位置（information retrieval 的常见做法）。 练习 3：构建 Suffix Trie（p15） 题目 Build the suffix trie for “amalgamation”. 课件提示（p13）：在末尾加 $，可保证“没有一个 suffix 是另一个 suffix 的前缀”。 所以这里构建 $X=\texttt{amalgamation}$ 的 suffix trie（用压缩边 label 的方式写，类似课件示例）。 解题思路（标准套路） 写出所有后缀（suffixes）：$X[i..]$ 把这些 suffix 全部插入 trie 若画“compressed suffix trie”，就把单链压缩成字符串边（更好写） Step 1：列出所有 suffix（加 $） 令 $X=\texttt{amalgamation}\$$（长度 13，包括 $），则后缀集合： 起点 i suffix 0 amalgamation$ 1 malgamation$ 2 algamation$ 3 lgamation$ 4 gamation$ 5 amation$ 6 mation$ 7 ation$ 8 tion$ 9 ion$ 10 on$ 11 n$ 12 $ 参考答案（Compressed Suffix Trie，用字符串做边 label） 说明：这是“压缩后”的 suffix trie（便于在 md 中展示）。每个叶子对应一个 suffix。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 (root) ├─ "$" • ├─ "a" (多个 suffix 以 a 开头) │ ├─ "lgamation$" • => algamation$ │ ├─ "tion$" • => ation$ │ └─ "ma" (共享前缀 "ama") │ ├─ "lgamation$" • => amalgamation$ │ └─ "tion$" • => amation$ ├─ "ma" (多个 suffix 以 "ma" 开头) │ ├─ "lgamation$" • => malgamation$ │ └─ "tion$" • => mation$ ├─ "lgamation$" • => lgamation$ ├─ "gamation$" • => gamation$ ├─ "tion$" • => tion$ ├─ "ion$" • => ion$ ├─ "on$" • => on$ └─ "n$" • => n$ 思考题 4：Using a suffix trie 做 substring 查询的复杂度（p14） 题目 如何用 suffix trie 判断模式串 $P$ 是否是文本 $T$ 的子串？时间复杂度是多少？ 参考答案 把 $T$ 的所有后缀建成 suffix trie。 判断 $P$ 是否为子串：从根出发沿着 $P$ 的字符尝试走一条路径： 若能走完 $P$（路径存在），则 $P$ 是 $T$ 的 substring 若中途断开，则不是 时间复杂度（课件结论）： $$O(m)$$ 其中 $m=|P|$。 一页速记（考前 60 秒） Standard trie：共享前缀；查找/插入/删除 $O(dm)$，用 hash/map 可到典型 $O(m)$ Compressed trie：消灭 single-child internal node；边可标字符串 Suffix trie：存 $T$ 的所有后缀（通常加 $）；substring 查询 $O(|P|)$ Leaf 常存：该词在文本中出现的位置 index（信息检索） ]]> https://www.mikusc.top/2026/01/08/comp4133aads-week6-graph-algorithms-1-exercises/ Week 6 练习题复习（Graph Algorithms 1）— 含答案与思路 覆盖内容：Graph 基本术语 + Graph ADT + 两种实现（matrix / list）+ BFS / DFS（含手算过程） + DFS 检测有向环 + BFS/DFS 复杂度 $O(|V|+|E|)$