[ { "id": "2023-judge-1", "year": 2023, "type": "judge", "number": 1, "title": "主定理与递归式", "tags": [ "递归与复杂度" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2023-judge-1-paper-1.webp" ], "paperText": "1. (T,\nF) 递归式T(n) = 4T(n/4)+nlgn 的解满足T(n) = Θ\n(\nn2 lgn\n)\n。\n", "paperPage": 1, "answers": [ "assets/2023-judge-1-answers-1.webp" ], "answersText": "1. (T,\nF) 递归式T(n) = 4T(n/4)+nlgn 的解满足T(n) = Θ\n(\nn2 lgn\n)\n。\nF 错误。\n由主定理可得，f(n) = Θ(nlog4 4 lgn)，则T(n) = Θ(nlg2 n)。\n", "answersPage": 1, "questionMarkdown": "递归式 $T(n)=4T(n/4)+n\\lg n$ 的解满足 $T(n)=\\Theta(n^2\\lg n)$。", "answerMarkdown": "**F，错误。** 主定理中 $n^{\\log_4 4}=n$，而 $f(n)=n\\lg n$，所以 $T(n)=\\Theta(n\\lg^2 n)$。", "questionHtml": "

递归式 T(n)=4T(n/4)+nlg⁡nT(n)=4T(n/4)+n\\lg nT(n)=4T(n/4)+nlgn 的解满足 T(n)=Θ(n2lg⁡n)T(n)=\\Theta(n^2\\lg n)T(n)=Θ(n2lgn)。

\n", "answerHtml": "

F，错误。 主定理中 nlog⁡44=nn^{\\log_4 4}=nnlog4​4=n，而 f(n)=nlg⁡nf(n)=n\\lg nf(n)=nlgn，所以 T(n)=Θ(nlg⁡2n)T(n)=\\Theta(n\\lg^2 n)T(n)=Θ(nlg2n)。

\n" }, { "id": "2023-judge-2", "year": 2023, "type": "judge", "number": 2, "title": "比较排序的最坏复杂度", "tags": [ "排序" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2023-judge-2-paper-1.webp" ], "paperText": "2. (T,\nF) 堆排序和快速排序都是渐近最优的比较排序算法，他们在最坏情况下都需要做O(nlgn)\n次比较。\n", "paperPage": 1, "answers": [ "assets/2023-judge-2-answers-1.webp" ], "answersText": "2. (T,\nF) 堆排序和快速排序都是渐近最优的比较排序算法，他们在最坏情况下都需要做O(nlgn)\n次比较。\nF 错误。\n快速排序在最坏情况下都需要做O(n2) 次比较。\n", "answersPage": 1, "questionMarkdown": "堆排序和快速排序都是渐近最优的比较排序算法，它们在最坏情况下都需要做 $O(n\\lg n)$ 次比较。", "answerMarkdown": "**F，错误。** 快速排序在最坏情况下需要 $\\Theta(n^2)$ 次比较，堆排序的最坏时间复杂度为 $\\Theta(n\\lg n)$。", "questionHtml": "

堆排序和快速排序都是渐近最优的比较排序算法，它们在最坏情况下都需要做 O(nlg⁡n)O(n\\lg n)O(nlgn) 次比较。

\n", "answerHtml": "

F，错误。 快速排序在最坏情况下需要 Θ(n2)\\Theta(n^2)Θ(n2) 次比较，堆排序的最坏时间复杂度为 Θ(nlg⁡n)\\Theta(n\\lg n)Θ(nlgn)。

\n" }, { "id": "2023-judge-3", "year": 2023, "type": "judge", "number": 3, "title": "选择排序与初始排列", "tags": [ "排序" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2023-judge-3-paper-1.webp" ], "paperText": "3. (T,\nF) 选择排序的时间复杂度与输入数据的初始排列有关。\n", "paperPage": 1, "answers": [ "assets/2023-judge-3-answers-1.webp" ], "answersText": "3. (T,\nF) 选择排序的时间复杂度与输入数据的初始排列有关。\nF 错误。\n选择排序的时间复杂度是O(n2)，与输入数据的初始排列无关。无论输入数据是什么样的排列，\n选择排序都需要进行相同数量的比较和交换操作。\n", "answersPage": 1, "questionMarkdown": "选择排序的时间复杂度与输入数据的初始排列有关。", "answerMarkdown": "**F，错误。** 标准选择排序无论输入初始排列如何，都要进行 $n(n-1)/2$ 次关键字比较，时间复杂度为 $\\Theta(n^2)$。", "questionHtml": "

选择排序的时间复杂度与输入数据的初始排列有关。

\n", "answerHtml": "

F，错误。 标准选择排序无论输入初始排列如何，都要进行 n(n−1)/2n(n-1)/2n(n−1)/2 次关键字比较，时间复杂度为 Θ(n2)\\Theta(n^2)Θ(n2)。

\n" }, { "id": "2023-judge-4", "year": 2023, "type": "judge", "number": 4, "title": "随机选择的期望时间", "tags": [ "选择算法", "概率分析" ], "points": 5, "correct": true, "note": "", "paper": [ "assets/2023-judge-4-paper-1.webp" ], "paperText": "4. (T,\nF) 在使用RANDOMIZED-SELECT 算法选择第k 大的元素时，算法的期望运行时间\n是线性的。\n", "paperPage": 2, "answers": [ "assets/2023-judge-4-answers-1.webp" ], "answersText": "4. (T,\nF) 在使用RANDOMIZED-SELECT 算法选择第k 大的元素时，算法的期望运行时间\n是线性的。\nT 正确。\nRANDOMIZED-SELECT 算法是随机化的选择算法，其期望运行时间为线性。在每次划分中，\n算法通过随机选择一个主元素，然后将数组划分为两部分，从而实现了平均情况下的线性运行时\n间。通过随机性的引入，RANDOMIZED-SELECT 能够避免最坏情况下的概率，从而保证期\n望运行时间为O(n)。\n", "answersPage": 1, "questionMarkdown": "在使用 RANDOMIZED-SELECT 算法选择第 $k$ 大的元素时，算法的期望运行时间是线性的。", "answerMarkdown": "**T，正确。** 随机化选择每次划分后只递归处理一侧，期望运行时间为 $\\Theta(n)$；最坏情况仍可能为 $\\Theta(n^2)$。", "questionHtml": "

在使用 RANDOMIZED-SELECT 算法选择第 kkk 大的元素时，算法的期望运行时间是线性的。

\n", "answerHtml": "

T，正确。 随机化选择每次划分后只递归处理一侧，期望运行时间为 Θ(n)\\Theta(n)Θ(n)；最坏情况仍可能为 Θ(n2)\\Theta(n^2)Θ(n2)。

\n" }, { "id": "2023-judge-5", "year": 2023, "type": "judge", "number": 5, "title": "从二叉堆到二叉搜索树", "tags": [ "排序", "二叉搜索树" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2023-judge-5-paper-1.webp" ], "paperText": "5. (T,\nF) 可以使用基于比较的算法，以O(n) 的最坏时间复杂度将二叉堆转换为二叉搜索树。\n", "paperPage": 2, "answers": [ "assets/2023-judge-5-answers-1.webp" ], "answersText": "5. (T,\nF) 可以使用基于比较的算法，以O(n) 的最坏时间复杂度将二叉堆转换为二叉搜索树。\nF\n如果这样的算法存在，那么对于一个无序数组，可以先用O(n) 时间建堆，再调用该算法用O(n)\n时间转换为二叉搜索树，再用O(n) 时间进行中序遍历，即得到排序后的数组，总用时为O(n)，\n这与基于比较的排序算法的最坏时间复杂度下界是Ω(nlgn) 矛盾。\n", "answersPage": 1, "questionMarkdown": "可以使用基于比较的算法，以 $O(n)$ 的最坏时间复杂度将二叉堆转换为二叉搜索树。", "answerMarkdown": "**F，错误。** 假设存在这样的算法，则可先用 $O(n)$ 时间将任意数组建堆，再转换为二叉搜索树，最后中序遍历得到排序结果，总时间为 $O(n)$，与比较排序的 $\\Omega(n\\lg n)$ 最坏下界矛盾。", "questionHtml": "

可以使用基于比较的算法，以 O(n)O(n)O(n) 的最坏时间复杂度将二叉堆转换为二叉搜索树。

\n", "answerHtml": "

F，错误。 假设存在这样的算法，则可先用 O(n)O(n)O(n) 时间将任意数组建堆，再转换为二叉搜索树，最后中序遍历得到排序结果，总时间为 O(n)O(n)O(n)，与比较排序的 Ω(nlg⁡n)\\Omega(n\\lg n)Ω(nlgn) 最坏下界矛盾。

\n" }, { "id": "2023-judge-6", "year": 2023, "type": "judge", "number": 6, "title": "红黑树的颜色反转", "tags": [ "红黑树" ], "points": 5, "correct": true, "note": "", "paper": [ "assets/2023-judge-6-paper-1.webp" ], "paperText": "6. (T,\nF) 如果把一棵红黑树除根节点和叶子节点外所有节点的颜色反转后，所得到的仍是合法\n的红黑树，那么任意一个节点的左右子树节点数相等。\n", "paperPage": 2, "answers": [ "assets/2023-judge-6-answers-1.webp" ], "answersText": "6. (T,\nF) 如果把一棵红黑树除根节点和叶子节点外所有节点的颜色反转后，所得到的仍是合法\n的红黑树，那么任意一个节点的左右子树节点数相等。\nT\n由红黑树性质以及颜色反转后的性质，任意一条从根节点到叶子节点的路径上红色节点和黑色\n节点的数量均相等，因此所有叶子节点的高度都相同，这说明这棵树的形状是完美对称的，因此\n任意一个节点的左右子树节点数相等。\n", "answersPage": 1, "questionMarkdown": "如果把一棵红黑树除根节点和叶子节点外所有节点的颜色反转后，所得到的仍是合法的红黑树，那么任意一个节点的左右子树节点数相等。", "answerMarkdown": "**T，正确。** 原树不能有相邻红节点；反色后的树也不能有相邻红节点，因此非根内部节点之间也不能相邻为黑。内部节点颜色必须逐层交替。结合每条根到 NIL 路径黑节点数相同，可得所有 NIL 叶子深度相同，树为完美二叉树，各节点左右子树节点数相等。", "questionHtml": "

如果把一棵红黑树除根节点和叶子节点外所有节点的颜色反转后，所得到的仍是合法的红黑树，那么任意一个节点的左右子树节点数相等。

\n", "answerHtml": "

T，正确。 原树不能有相邻红节点；反色后的树也不能有相邻红节点，因此非根内部节点之间也不能相邻为黑。内部节点颜色必须逐层交替。结合每条根到 NIL 路径黑节点数相同，可得所有 NIL 叶子深度相同，树为完美二叉树，各节点左右子树节点数相等。

\n" }, { "id": "2023-short-1", "year": 2023, "type": "short", "number": 1, "title": "取整指数递归式", "tags": [ "递归与复杂度" ], "points": 10, "correct": null, "note": "", "paper": [ "assets/2023-short-1-paper-1.webp" ], "paperText": "1. 对于递归式T(n) = T(2n/3)+2⌈lgn⌉，给出T(n) 的一个渐近紧确界。\n（注：2lgn = n）\n", "paperPage": 2, "answers": [ "assets/2023-short-1-answers-1.webp" ], "answersText": "1. 对于递归式T(n) = T(2n/3)+2⌈lgn⌉，给出T(n) 的一个渐近紧确界。\n（注：2lgn = n）\n解：\n定义F(n) = F(2n/3)+n,G(n) = G(2n/3)+2n，则由主定理显然有：F(n) = Θ(n),G(n) = Θ(n)，而\nn = 2lgn ≤2⌈lgn⌉≤2(lgn)+1 = 2n，因此F(n) ≤T(n) ≤G(n)，故T(n) = Θ(n)\n", "answersPage": 2, "questionMarkdown": "对于递归式\n$$T(n)=T(2n/3)+2^{\\lceil\\lg n\\rceil},$$\n给出 $T(n)$ 的一个渐近紧确界。\n\n注：$2^{\\lg n}=n$。", "answerMarkdown": "由 $\\lg n\\le\\lceil\\lg n\\rceil<\\lg n+1$ 可得\n$$n\\le 2^{\\lceil\\lg n\\rceil}<2n.$$\n因此非递归代价为 $\\Theta(n)$。用 $F(n)=F(2n/3)+n$ 和 $G(n)=G(2n/3)+2n$ 夹逼，二者均为 $\\Theta(n)$，所以\n$$T(n)=\\Theta(n).$$", "questionHtml": "

对于递归式

\nT(n)=T(2n/3)+2⌈lg⁡n⌉,T(n)=T(2n/3)+2^{\\lceil\\lg n\\rceil},T(n)=T(2n/3)+2⌈lgn⌉,\n

给出 T(n)T(n)T(n) 的一个渐近紧确界。

\n

注：2lg⁡n=n2^{\\lg n}=n2lgn=n。

\n", "answerHtml": "

由 lg⁡n≤⌈lg⁡n⌉<lg⁡n+1\\lg n\\le\\lceil\\lg n\\rceil<\\lg n+1lgn≤⌈lgn⌉<lgn+1 可得

\nn≤2⌈lg⁡n⌉<2n.n\\le 2^{\\lceil\\lg n\\rceil}<2n.n≤2⌈lgn⌉<2n.\n

因此非递归代价为 Θ(n)\\Theta(n)Θ(n)。用 F(n)=F(2n/3)+nF(n)=F(2n/3)+nF(n)=F(2n/3)+n 和 G(n)=G(2n/3)+2nG(n)=G(2n/3)+2nG(n)=G(2n/3)+2n 夹逼，二者均为 Θ(n)\\Theta(n)Θ(n)，所以

\nT(n)=Θ(n).T(n)=\\Theta(n).T(n)=Θ(n).\n" }, { "id": "2023-short-2", "year": 2023, "type": "short", "number": 2, "title": "随机快速排序：补全与调用次数", "tags": [ "排序", "伪代码" ], "points": 10, "correct": null, "note": "", "paper": [ "assets/2023-short-2-paper-1.webp" ], "paperText": "2. 补全算法Randomized-Quicksort（A 为数组）的伪代码，并分析Randomized-Quicksort(A,1,n)\n（n = A.length）运行过程中，在最坏和最好情况下，Randomized-Quicksort 分别被调用了多\n少次？（以Θ 符号形式给出答案）\nAlgorithm 1 Partition(A, p,r)\n1: x = A[r]\n2: i = ___\n3: for j = p to ___ do\n4:\nif ______ then\n5:\ni = i+1\n6:\nA[i] ↔A[j]\n7: A[i+1] ↔A[r]\n8: Return i+1\nAlgorithm 2 Randomized-Partition(A, p,r)\n1: i = Random(p,r)\n2: A[r] ↔A[i]\n3: Return Partition(A, p,r)\nAlgorithm 3 Randomized-Quicksort(A, p,r)\n1: if ___ then\n2:\nq = Randomized-Partition(A, p,r)\n3:\nRandomized-Quicksort(A, p,___)\n4:\nRandomized-Quicksort(A,___,r)\n", "paperPage": 3, "answers": [ "assets/2023-short-2-answers-1.webp" ], "answersText": "2. 给出算法Randomized-Quicksort 的伪代码，并分析Randomized-Quicksort(A,1,n) 运行\n过程中，在最坏和最好情况下，Randomized-Quicksort 分别被调用了多少次？（以Θ 符号形\n式给出答案）\n在最坏和最好情况下，Randomized-Quicksort 分别被调用了Θ(n) 次。\nAlgorithm 1 Partition(A, p,r)\n1: x = A[r]\n2: i = p−1\n3: for j = p to r −1 do\n4:\nif A[j] ≤x then\n5:\ni = i+1\n6:\nA[i] ↔A[j]\n7: A[i+1] ↔A[r]\n8: Return i+1\nAlgorithm 2 Randomized-Partition(A, p,r)\n1: i = Random(p,r)\n2: A[r] ↔A[i]\n3: Return Partition(A, p,r)\nAlgorithm 3 Randomized-Quicksort(A, p,r)\n1: if p < r then\n2:\nq = Randomized-Partition(A, p,r)\n3:\nRandomized-Quicksort(A, p,q−1)\n4:\nRandomized-Quicksort(A,q+1,r)\n", "answersPage": 2, "questionMarkdown": "补全算法 Randomized-Quicksort（$A$ 为数组）的伪代码，并分析 Randomized-Quicksort$(A,1,n)$（$n=A.\\mathrm{length}$）运行过程中，在最坏和最好情况下，Randomized-Quicksort 分别被调用了多少次？以 $\\Theta$ 符号形式给出答案。\n\n```text\nPARTITION(A, p, r)\n x = A[r]\n i = ____\n for j = p to ____\n if ____\n i = i + 1\n swap(A[i], A[j])\n swap(A[i + 1], A[r])\n return i + 1\n\nRANDOMIZED-PARTITION(A, p, r)\n i = RANDOM(p, r)\n swap(A[r], A[i])\n return PARTITION(A, p, r)\n\nRANDOMIZED-QUICKSORT(A, p, r)\n if ____\n q = RANDOMIZED-PARTITION(A, p, r)\n RANDOMIZED-QUICKSORT(A, p, ____)\n RANDOMIZED-QUICKSORT(A, ____, r)\n```", "answerMarkdown": "依次填入：$p-1$、$r-1$、$A[j]\\le x$、$p补全算法 Randomized-Quicksort（AAA 为数组）的伪代码，并分析 Randomized-Quicksort(A,1,n)(A,1,n)(A,1,n)（n=A.lengthn=A.\\mathrm{length}n=A.length）运行过程中，在最坏和最好情况下，Randomized-Quicksort 分别被调用了多少次？以 Θ\\ThetaΘ 符号形式给出答案。

\n
PARTITION(A, p, r)\n    x = A[r]\n    i = ____\n    for j = p to ____\n        if ____\n            i = i + 1\n            swap(A[i], A[j])\n    swap(A[i + 1], A[r])\n    return i + 1\n\nRANDOMIZED-PARTITION(A, p, r)\n    i = RANDOM(p, r)\n    swap(A[r], A[i])\n    return PARTITION(A, p, r)\n\nRANDOMIZED-QUICKSORT(A, p, r)\n    if ____\n        q = RANDOMIZED-PARTITION(A, p, r)\n        RANDOMIZED-QUICKSORT(A, p, ____)\n        RANDOMIZED-QUICKSORT(A, ____, r)\n
\n", "answerHtml": "

依次填入：p−1p-1p−1、r−1r-1r−1、A[j]≤xA[j]\\le xA[j]≤x、p<rp<rp<r、q−1q-1q−1、q+1q+1q+1。

\n
RANDOMIZED-QUICKSORT(A, p, r)\n    if p < r\n        q = RANDOMIZED-PARTITION(A, p, r)\n        RANDOMIZED-QUICKSORT(A, p, q - 1)\n        RANDOMIZED-QUICKSORT(A, q + 1, r)\n
\n

最坏和最好情况下，函数调用总次数均为 Θ(n)\\Theta(n)Θ(n)。每个非平凡子问题确定一个枢轴，两次递归调用形成一棵总节点数线性的递归树。调用次数不要与总比较次数或递归深度混淆。

\n" }, { "id": "2023-short-3", "year": 2023, "type": "short", "number": 3, "title": "有序数组中的相反数对", "tags": [ "双指针" ], "points": 10, "correct": null, "note": "原答案伪代码有笔误：循环条件应为 l < r；和大于 0 时应执行 r ← r − 1，而不是修改 n。两个指针必须对应不同下标。", "paper": [ "assets/2023-short-3-paper-1.webp" ], "paperText": "3. 给定n 个已经排好序的元素a0,...,an−1，请给出时间复杂度为O(n) 的算法来判断是否存在元素\n对满足ai = −aj,i ̸= j。给出伪代码，并说明算法的工作原理。\n", "paperPage": 3, "answers": [ "assets/2023-short-3-answers-1.webp", "assets/2023-short-3-answers-2.webp" ], "answersText": "3. 给定n 个已经排好序的元素a0,...,an−1，请给出时间复杂度为O(n) 的算法来判断是否存在元素\n对满足ai = −aj,i ̸= j。给出伪代码，并说明算法工作原理。\n\n解：\n做向内搜索。基本思想是：如果aleft +aright > 0，那么right −−，否则如果aleft +aright < 0，那\n么left ++。\nAlgorithm 4 向内搜索\n1: l = 0; r = n−1\n2: while l < n do\n3:\nif al +ar > 0 then\n4:\nn = n−1\n5:\nelse\n6:\nif al +ar < 0 then\n7:\nl = l +1\n8:\nelse\n9:\nReturn True\n10: Return False\n", "answersPage": 2, "questionMarkdown": "给定 $n$ 个已经排好序的元素 $a_0,\\ldots,a_{n-1}$，请给出时间复杂度为 $O(n)$ 的算法来判断是否存在元素对满足 $a_i=-a_j$，$i\\ne j$。给出伪代码，并说明算法的工作原理。", "answerMarkdown": "采用左右双指针向内搜索。以下按非递减顺序给出伪代码，修正了原答案中的循环边界与变量笔误。\n\n```text\nOPPOSITE-PAIR(a, n)\n l = 0\n r = n - 1\n while l < r\n s = a[l] + a[r]\n if s == 0\n return True\n if s > 0\n r = r - 1\n else\n l = l + 1\n return False\n```\n\n若和大于 $0$，则当前右端值不可能与剩余任何值组成零和，应缩小右端；若和小于 $0$，同理增大左端。条件 $l给定 nnn 个已经排好序的元素 a0,…,an−1a_0,\\ldots,a_{n-1}a0​,…,an−1​，请给出时间复杂度为 O(n)O(n)O(n) 的算法来判断是否存在元素对满足 ai=−aja_i=-a_jai​=−aj​，i≠ji\\ne ji=j。给出伪代码，并说明算法的工作原理。

\n", "answerHtml": "

采用左右双指针向内搜索。以下按非递减顺序给出伪代码，修正了原答案中的循环边界与变量笔误。

\n
OPPOSITE-PAIR(a, n)\n    l = 0\n    r = n - 1\n    while l < r\n        s = a[l] + a[r]\n        if s == 0\n            return True\n        if s > 0\n            r = r - 1\n        else\n            l = l + 1\n    return False\n
\n

若和大于 000，则当前右端值不可能与剩余任何值组成零和，应缩小右端；若和小于 000，同理增大左端。条件 l<rl<rl<r 保证下标不同。两个指针各最多移动 nnn 次，时间为 O(n)O(n)O(n)，辅助空间为 O(1)O(1)O(1)。

\n" }, { "id": "2023-short-4", "year": 2023, "type": "short", "number": 4, "title": "斐波那契堆：抽取与级联切断", "tags": [ "斐波那契堆" ], "points": 10, "correct": null, "note": "", "paper": [ "assets/2023-short-4-paper-1.webp" ], "paperText": "4. 对于图一所给的斐波那契堆, 黑色节点表示结点的mark 属性为true:\n1) 抽取最小结点(需要考虑CONSOLIDATE 操作), 画出操作后最后的结果。\n2) 在1）的基础上，把关键字25 减为3, 画出操作后的最后的结果(需考虑级联操作)。\nGiven a Fibonacci heap below. the mark attribute of black node is true:\n1)Please give the result of extracting the minimum node (CONSOLIDATE should be considered).\n2)Please give the result of decrease the value of key 25 down to 3, based on the result of 1).\n图1: 斐波那契堆\nFig. 1 Fibonacci Heap\n", "paperPage": 4, "answers": [ "assets/2023-short-4-answers-1.webp", "assets/2023-short-4-answers-2.webp", "assets/2023-short-4-answers-3.webp" ], "answersText": "4. 对于图一所给的斐波那契堆, 黑色节点表示结点的mark 属性为true:\n1) 抽取最小结点(需要考虑CONSOLIDATE 操作), 画出操作后最后的结果。\n2) 在1）的基础上，把关键字25 减为3, 画出操作后的最后的结果(需考虑级联操作)。\nGiven a Fibonacci heap below. the mark attribute of black node is true:\n1)Please give the result of extracting the minimum node (CONSOLIDATE should be considered).\n2)Please give the result of decrease the value of key 25 down to 3, based on the result of 1).\n图1: 斐波那契堆\nFig. 1 Fibonacci Heap\n\n1)\n\n2)\n", "answersPage": 4, "questionMarkdown": "对于下图所给的斐波那契堆，黑色节点表示结点的 `mark` 属性为 `true`：\n\n1. 抽取最小结点，画出操作后的最终结果，需要考虑 CONSOLIDATE（合并）操作。\n2. 在第 1 问的基础上，把关键字 $25$ 减为 $3$，画出操作后的最终结果，需要考虑 CASCADING-CUT（级联切断）操作。\n\n{{QUESTION_DIAGRAM}}", "answerMarkdown": "**第 1 问：抽取最小结点。** 将最小结点的孩子加入根链表，删除最小结点，再反复合并度数相同的根。合并时较小关键字成为父节点，最后更新最小指针。\n\n{{ANSWER_DIAGRAM_1}}\n\n**第 2 问：降低关键字。** 将 $25$ 改为 $3$。若它小于父节点，则切断并加入根链表；对原父节点执行级联切断：未标记的非根结点先置标记，已标记的非根结点继续切断。移到根链表的结点清除标记，再更新最小指针。\n\n{{ANSWER_DIAGRAM_2}}\n\n上图保留配套答案中的结构示意。根链表顺序及同度根的合并顺序可以不同，应核对堆序、父子关系、度数、标记和最小指针。", "questionHtml": "

对于下图所给的斐波那契堆，黑色节点表示结点的 mark 属性为 true：

\n
    \n
  1. 抽取最小结点，画出操作后的最终结果，需要考虑 CONSOLIDATE（合并）操作。
    2. \n
  2. 在第 1 问的基础上，把关键字 252525 减为 333，画出操作后的最终结果，需要考虑 CASCADING-CUT（级联切断）操作。
    3. \n
\n
\"2023
原卷结构图 · 点击放大
\n", "answerHtml": "

第 1 问：抽取最小结点。 将最小结点的孩子加入根链表，删除最小结点，再反复合并度数相同的根。合并时较小关键字成为父节点，最后更新最小指针。

\n
\"2023
原卷结构图 · 点击放大
\n

第 2 问：降低关键字。 将 252525 改为 333。若它小于父节点，则切断并加入根链表；对原父节点执行级联切断：未标记的非根结点先置标记，已标记的非根结点继续切断。移到根链表的结点清除标记，再更新最小指针。

\n
\"2023
原卷结构图 · 点击放大
\n

上图保留配套答案中的结构示意。根链表顺序及同度根的合并顺序可以不同，应核对堆序、父子关系、度数、标记和最小指针。

\n" }, { "id": "2023-comprehensive-1", "year": 2023, "type": "comprehensive", "number": 1, "title": "线性时间排序：基数与桶", "tags": [ "排序", "概率分析" ], "points": 15, "correct": null, "note": "", "paper": [ "assets/2023-comprehensive-1-paper-1.webp" ], "paperText": "1. (a) 说明如何以O(n) 的最坏时间复杂度对\n[\n1,n2]\n范围内的n 个整数排序。假设整数已经在你需要\n的基上，也就是说，你不需要对它们进行进制转换。\n(b) 对于常数m ∈N+，给定长度为n(n > m) 的数列Z，已知Z 中每个元素都以这样的方式生成：\nZi = Xi +Yi，离散随机变量Xi 在\n{\n0, 1\nm, 2\nm,..., m−1\nm\n}\n中随机均匀取值，连续随机变量Yi 在\n(\n0, 1\nn\n)\n上随\n机均匀取值，所有Xi,Yi 均独立。请设计一个桶排序算法，以O(n) 的期望时间复杂度对Z 进行排序。\n你只需给出算法简要流程，不需要对这一时间复杂度进行证明。\n提示：第二问中，为达到O(n) 的期望时间复杂度，你需要设计Θ(n) 个桶，并尽可能均匀地将Z\n中的元素分配到桶中。\n", "paperPage": 5, "answers": [ "assets/2023-comprehensive-1-answers-1.webp" ], "answersText": "1. 线性时间排序算法\n(a) 说明如何以O(n) 的最坏时间复杂度对\n[\n1,n2]\n范围内的n 个整数排序。假设整数已经在你需要的\n基上，也就是说，你不需要对它们进行进制转换。\n(b) 对于常数m ∈N+，给定长度为n(n > m) 的数列Z，已知Z 中每个元素都以这样的方式生成：\nZi = Xi +Yi，离散随机变量Xi 在\n{\n0, 1\nm, 2\nm,..., m−1\nm\n}\n中随机均匀取值，连续随机变量Yi 在\n(\n0, 1\nn\n)\n上随\n机均匀取值，所有Xi,Yi 均独立。请设计一个桶排序算法，以O(n) 的期望时间复杂度对Z 进行排序。\n你只需给出算法简要流程，不需要对这一时间复杂度进行证明。\n提示：第二问中，为达到O(n) 的期望时间复杂度，你需要设计Θ(n) 个桶，并尽可能均匀地将Z\n中的元素分配到桶中。\n解：\n(a) 以n 为基底使用基数排序。由于数字以n 为基底，因此位数的范围为1 到n（准确地说是0\n到n −1），所以k = n。由于n2 = 100n，所以d = 3。故基数排序的时间复杂度为Θ(d · n + d · k) =\nΘ(3n+3n) = Θ(n) ∈O(n)。\n(b) 因为Yi < 1\nn < 1\nm，易验证，对任意Zi，Xi = ⌊mZi⌋\nm ，因此可以用这种方式将Zi 对应的Xi,Yi 分解\n出来。建立m 个“大桶”，每个“大桶”里有n 个“小桶”。对于每个Zi，根据Xi 的值决定它进入哪个\n大桶，再根据Yi 的值决定它进入哪个小桶。因为Xi 和Yi 都是均匀的，因此Zi 在期望意义上被均匀地\n分配到桶中，从而具有线性时间复杂度。\n具体而言，对于桶B(x,y),x ∈[0,m−1],y ∈[0,n−1]，其内放置的元素范围应为\n(\nx\nm + y\nn2 , x\nm + y+1\nn2\n)\n", "answersPage": 7, "questionMarkdown": "**(a)** 说明如何以 $O(n)$ 的最坏时间复杂度对 $[1,n^2]$ 范围内的 $n$ 个整数排序。假设整数已经在你需要的基上，即不需要进行进制转换。\n\n**(b)** 对于常数 $m\\in\\mathbb N^+$，给定长度为 $n$（$n>m$）的数列 $Z$，其每个元素由 $Z_i=X_i+Y_i$ 生成，其中\n$$X_i\\in\\left\\{0,\\frac1m,\\frac2m,\\ldots,\\frac{m-1}{m}\\right\\}$$\n离散均匀取值，$Y_i$ 在 $(0,1/n)$ 上连续均匀取值，所有 $X_i,Y_i$ 均独立。\n\n请设计一个桶排序算法，以 $O(n)$ 的期望时间复杂度对 $Z$ 排序。只需简述算法流程，不需要证明时间复杂度。\n\n提示：应设计 $\\Theta(n)$ 个桶，尽可能均匀地分配元素。", "answerMarkdown": "**(a)** 以 $n$ 为基做稳定基数排序。关键字最大为 $n^2=(100)_n$，因此至多 $3$ 位，每一位用计数排序，代价为 $\\Theta(n+n)$。总时间为 $\\Theta(3n)=\\Theta(n)$。\n\n**(b)** 由于 $Y_i<1/n<1/m$，可还原\n$$x=\\lfloor mZ_i\\rfloor,\\qquad Y_i=Z_i-\\frac{x}{m}.$$\n建立 $m$ 个大桶，每个大桶再分 $n$ 个小桶。将 $Z_i$ 放入编号为 $(x,y)$ 的桶，其中\n$$y=\\left\\lfloor n^2\\left(Z_i-\\frac{x}{m}\\right)\\right\\rfloor.$$\n桶 $(x,y)$ 对应半开区间 $[x/m+y/n^2,\\ x/m+(y+1)/n^2)$；小桶边界用半开区间实现以覆盖所有值。总桶数 $mn=\\Theta(n)$，因为 $m$ 是常数。每桶内部用插入排序，最后按大桶、小桶顺序串联。各桶等概率，故期望总时间为 $O(n)$。", "questionHtml": "

(a) 说明如何以 O(n)O(n)O(n) 的最坏时间复杂度对 [1,n2][1,n^2][1,n2] 范围内的 nnn 个整数排序。假设整数已经在你需要的基上，即不需要进行进制转换。

\n

(b) 对于常数 m∈N+m\\in\\mathbb N^+m∈N+，给定长度为 nnn（n>mn>mn>m）的数列 ZZZ，其每个元素由 Zi=Xi+YiZ_i=X_i+Y_iZi​=Xi​+Yi​ 生成，其中

\nXi∈{0,1m,2m,…,m−1m}X_i\\in\\left\\{0,\\frac1m,\\frac2m,\\ldots,\\frac{m-1}{m}\\right\\}Xi​∈{0,m1​,m2​,…,mm−1​}\n

离散均匀取值，YiY_iYi​ 在 (0,1/n)(0,1/n)(0,1/n) 上连续均匀取值，所有 Xi,YiX_i,Y_iXi​,Yi​ 均独立。

\n

请设计一个桶排序算法，以 O(n)O(n)O(n) 的期望时间复杂度对 ZZZ 排序。只需简述算法流程，不需要证明时间复杂度。

\n

提示：应设计 Θ(n)\\Theta(n)Θ(n) 个桶，尽可能均匀地分配元素。

\n", "answerHtml": "

(a) 以 nnn 为基做稳定基数排序。关键字最大为 n2=(100)nn^2=(100)_nn2=(100)n​，因此至多 333 位，每一位用计数排序，代价为 Θ(n+n)\\Theta(n+n)Θ(n+n)。总时间为 Θ(3n)=Θ(n)\\Theta(3n)=\\Theta(n)Θ(3n)=Θ(n)。

\n

(b) 由于 Yi<1/n<1/mY_i<1/n<1/mYi​<1/n<1/m，可还原

\nx=⌊mZi⌋,Yi=Zi−xm.x=\\lfloor mZ_i\\rfloor,\\qquad Y_i=Z_i-\\frac{x}{m}.x=⌊mZi​⌋,Yi​=Zi​−mx​.\n

建立 mmm 个大桶，每个大桶再分 nnn 个小桶。将 ZiZ_iZi​ 放入编号为 (x,y)(x,y)(x,y) 的桶，其中

\ny=⌊n2(Zi−xm)⌋.y=\\left\\lfloor n^2\\left(Z_i-\\frac{x}{m}\\right)\\right\\rfloor.y=⌊n2(Zi​−mx​)⌋.\n

桶 (x,y)(x,y)(x,y) 对应半开区间 [x/m+y/n2, x/m+(y+1)/n2)[x/m+y/n^2,\\ x/m+(y+1)/n^2)[x/m+y/n2, x/m+(y+1)/n2)；小桶边界用半开区间实现以覆盖所有值。总桶数 mn=Θ(n)mn=\\Theta(n)mn=Θ(n)，因为 mmm 是常数。每桶内部用插入排序，最后按大桶、小桶顺序串联。各桶等概率，故期望总时间为 O(n)O(n)O(n)。

\n" }, { "id": "2023-comprehensive-2", "year": 2023, "type": "comprehensive", "number": 2, "title": "AVL 树：高度与平衡操作", "tags": [ "平衡树", "伪代码" ], "points": 15, "correct": null, "note": "", "paper": [ "assets/2023-comprehensive-2-paper-1.webp" ], "paperText": "2. 二叉搜索树一定程度上可以提高搜索效率，但在最坏情况下，仍需要O(n) 时间完成一次搜索，因\n此需要引入平衡二叉搜索树。AVL 树是一种高度平衡的二叉搜索树：对于每个结点，其左子树与右子\n树的高度差不超过1。为实现一棵AVL 树，需要在每个节点内维护一个额外的属性：height[x] 为结点\nx 的高度。此外，我们还定义平衡因子（Balance Factor）：BF[x] 为结点x 左右子树的高度差，取值为\n0、1、-1，分别对应着左右子树等高，左子树比右子树高，右子树比左子树高。\n(a) 已知一颗AVL 树上的结点x′，BF[left[x′]] = 0，BF[right[x′]] = 1, 试问BF[x′] 的值。\n(b) 证明：一棵有n 个结点的AVL 树高度为O(lgn)。\n(c) 在一棵AVL 树中插入一个结点，首先以二叉搜索树的顺序把该结点放在适当的位置上。此时，可\n能某些结点的平衡因子可能为2 或-2。请补全出算法AVL-Balance(x) 的伪代码，输入一棵以x 为\n根的子树，其左右子树都是高度平衡的，若BF[x] 为2 或-2，将其转变为高度平衡的，返回调整后的\n子树的根，否则直接返回x。\nAlgorithm 4 AVL-Balance(x)\n1: if |BF[x]| ≤1 then\n2:\nReturn x\n3: else if ______ then\n4:\ny = ____\n5:\nif __________ then\n6:\nLeft-Rotate(y)\n7:\nReturn __________\n8: else\n9:\n______\n10:\nif __________ then\n11:\n____________\n12:\nReturn __________\n", "paperPage": 6, "answers": [ "assets/2023-comprehensive-2-answers-1.webp" ], "answersText": "2. 二叉搜索树一定程度上可以提高搜索效率，但在最坏情况下，仍需要O(n) 时间完成一次搜索，因\n此需要引入平衡二叉搜索树。AVL 树是一种高度平衡的二叉搜索树：对于每个结点，其左子树与右子\n树的高度差不超过1。为实现一棵AVL 树，需要在每个节点内维护一个额外的属性：height[x] 为结点\nx 的高度。此外，我们还定义平衡因子（Balance Factor）：BF[x] 为结点x 左右子树的高度差，取值为\n0、1、-1，分别对应着左右子树等高，左子树比右子树高，右子树比左子树高。\n(a) 已知一颗AVL 树上的结点x′，BF[left[x′]] = 0，BF[right[x′]] = 1, 试问BF[x′] 的值。\nBF[x′] 的值可能是0、1 或−1。\n(b) 证明：一棵有n 个结点的AVL 树高度为O(lgn)。\n对于斐波那契数列有F(0) = 1，F(1) = 1，F(2) = 2，F(n) = F(n−1)+F(n−2)。\n设T(h) 为高度为h 的AVL 树的最少结点数，则有T(1) ≥F(1)，T(2) ≥F(2)。\n又有T(h) ≥T(h−1)+T(h−2)+1 ≥F(h−1)+F(h−2)+1 > F(h)。\n又有1.6h ≤F(h) ≤2h，故有T(h) ≥1.6h。所以，一棵有n 个结点的AVL 树高度为O(lgn)。\n(c) 在一棵AVL 树中插入一个结点，首先以二叉搜索树的顺序把该结点放在适当的位置上。此时，可\n能某些结点的平衡因子可能为2 或-2。请给出算法AVL-Balance(x) 的伪代码，输入一棵以x 为根\n的子树，其左右子树都是高度平衡的，若BF[x] 为2 或-2，将其转变为高度平衡的，返回调整后的子\n树的根，否则直接返回x。\nAlgorithm 5 AVL-Balance(x)\n1: if |BF[x]| ≤1 then\n2:\nReturn x\n3: else if BF[x] = 2 then\n4:\ny = left[x]\n5:\nif height[left[y]] < height[right[y]] then\n6:\nLeft-Rotate(y)\n7:\nReturn Right-Rotate(x)\n8: else\n9:\ny = right[x]\n10:\nif height[left[y]] > height[right[y]] then\n11:\nRight-Rotate(y)\n12:\nReturn Left-Rotate(x)\n", "answersPage": 8, "questionMarkdown": "二叉搜索树在最坏情况下仍需 $O(n)$ 时间完成一次搜索，因此需要引入平衡二叉搜索树。AVL 树要求每个结点左右子树的高度差不超过 $1$。\n\n维护 `height[x]` 表示结点高度，平衡因子 `BF[x]` 为左子树高度减右子树高度；取 $0,1,-1$ 时，分别表示等高、左高、右高。\n\n**(a)** 已知某结点 $x'$ 满足 $\\mathrm{BF}[\\mathrm{left}[x']]=0$，$\\mathrm{BF}[\\mathrm{right}[x']]=1$，求 $\\mathrm{BF}[x']$ 的可能值。\n\n**(b)** 证明：有 $n$ 个结点的 AVL 树高度为 $O(\\lg n)$。\n\n**(c)** 插入结点后，某些结点的平衡因子可能为 $2$ 或 $-2$。补全 AVL-Balance$(x)$：输入以 $x$ 为根且左右子树都高度平衡的子树，将其恢复平衡并返回调整后的根；无需调整则返回 $x$。\n\n```text\nAVL-BALANCE(x)\n if |BF[x]| <= 1\n return x\n else if ____\n y = ____\n if ____\n LEFT-ROTATE(y)\n return ____\n else\n ____\n if ____\n ____\n return ____\n```", "answerMarkdown": "**(a)** 可能为 $-1,0,1$。仅知道两个孩子自身的平衡因子，不能确定两个孩子的绝对高度。\n\n**(b)** 令 $N(h)$ 为高度 $h$ 的 AVL 树的最少结点数，取空树高度为 $-1$。有\n$$N(-1)=0,\\quad N(0)=1,$$\n$$N(h)=1+N(h-1)+N(h-2).$$\n该递推按斐波那契速度增长，即 $N(h)=\\Omega(\\varphi^h)$，$\\varphi=(1+\\sqrt5)/2$。因此 $n\\ge N(h)$ 蕴含 $h=O(\\lg n)$。\n\n**(c)**\n```text\nAVL-BALANCE(x)\n if |BF[x]| <= 1\n return x\n else if BF[x] == 2\n y = left[x]\n if height[left[y]] < height[right[y]]\n LEFT-ROTATE(y)\n return RIGHT-ROTATE(x)\n else\n y = right[x]\n if height[left[y]] > height[right[y]]\n RIGHT-ROTATE(y)\n return LEFT-ROTATE(x)\n```\n\n旋转操作应同步维护父子指针和受影响结点的高度。", "questionHtml": "

二叉搜索树在最坏情况下仍需 O(n)O(n)O(n) 时间完成一次搜索，因此需要引入平衡二叉搜索树。AVL 树要求每个结点左右子树的高度差不超过 111。

\n

维护 height[x] 表示结点高度，平衡因子 BF[x] 为左子树高度减右子树高度；取 0,1,−10,1,-10,1,−1 时，分别表示等高、左高、右高。

\n

(a) 已知某结点 x′x'x′ 满足 BF[left[x′]]=0\\mathrm{BF}[\\mathrm{left}[x']]=0BF[left[x′]]=0，BF[right[x′]]=1\\mathrm{BF}[\\mathrm{right}[x']]=1BF[right[x′]]=1，求 BF[x′]\\mathrm{BF}[x']BF[x′] 的可能值。

\n

(b) 证明：有 nnn 个结点的 AVL 树高度为 O(lg⁡n)O(\\lg n)O(lgn)。

\n

(c) 插入结点后，某些结点的平衡因子可能为 222 或 −2-2−2。补全 AVL-Balance(x)(x)(x)：输入以 xxx 为根且左右子树都高度平衡的子树，将其恢复平衡并返回调整后的根；无需调整则返回 xxx。

\n
AVL-BALANCE(x)\n    if |BF[x]| <= 1\n        return x\n    else if ____\n        y = ____\n        if ____\n            LEFT-ROTATE(y)\n        return ____\n    else\n        ____\n        if ____\n            ____\n        return ____\n
\n", "answerHtml": "

(a) 可能为 −1,0,1-1,0,1−1,0,1。仅知道两个孩子自身的平衡因子，不能确定两个孩子的绝对高度。

\n

(b) 令 N(h)N(h)N(h) 为高度 hhh 的 AVL 树的最少结点数，取空树高度为 −1-1−1。有

\nN(−1)=0,N(0)=1,N(-1)=0,\\quad N(0)=1,N(−1)=0,N(0)=1,\nN(h)=1+N(h−1)+N(h−2).N(h)=1+N(h-1)+N(h-2).N(h)=1+N(h−1)+N(h−2).\n

该递推按斐波那契速度增长，即 N(h)=Ω(φh)N(h)=\\Omega(\\varphi^h)N(h)=Ω(φh)，φ=(1+5)/2\\varphi=(1+\\sqrt5)/2φ=(1+5​)/2。因此 n≥N(h)n\\ge N(h)n≥N(h) 蕴含 h=O(lg⁡n)h=O(\\lg n)h=O(lgn)。

\n

(c)

\n
AVL-BALANCE(x)\n    if |BF[x]| <= 1\n        return x\n    else if BF[x] == 2\n        y = left[x]\n        if height[left[y]] < height[right[y]]\n            LEFT-ROTATE(y)\n        return RIGHT-ROTATE(x)\n    else\n        y = right[x]\n        if height[left[y]] > height[right[y]]\n            RIGHT-ROTATE(y)\n        return LEFT-ROTATE(x)\n
\n

旋转操作应同步维护父子指针和受影响结点的高度。

\n" }, { "id": "2023-bonus-1", "year": 2023, "type": "bonus", "number": 1, "title": "连续刷题方案与区间和计数", "tags": [ "区间问题", "分治" ], "points": 10, "correct": null, "note": "", "paper": [ "assets/2023-bonus-1-paper-1.webp" ], "paperText": "四、附加题（根据题目要求写出解答过程，共10 分）。\n为了在算法基础课程期中考试中取得好成绩，小花同学在考前狂刷《算法导论》课后习题。在不刷\n任何题的情况下，小花能够考S 分。《算法导论》中共有n 道题，刷第i 题能使她的期中考试成绩提升\nsi（si ≥0）。但与此同时，刷题会产生疲劳，进而影响考试发挥，如果小花一共刷了k 道题，则她会因\n为疲劳而损失αk 分（α ≥0）。小花不喜欢跳着刷题，也不喜欢倒着刷题，更不喜欢重复刷题，因此她\n只会从某一题开始刷连续的若干题。假设小花希望让自己的最终分数落入[l,r]，请问她有多少种刷题\n方案？试设计一个具有O(nlgn) 最坏时间复杂度的算法解决该问题。（在小花所处的平行世界中，考试\n的分数未必是0 ∼100 的整数，因此你不能使用计数排序等对数据范围有限制的方法）\n", "paperPage": 7, "answers": [ "assets/2023-bonus-1-answers-1.webp" ], "answersText": "四、附加题（根据题目要求写出解答过程，共10 分）。\n为了在算法基础课程期中考试中取得好成绩，小花同学在考前狂刷《算法导论》课后习题。在不刷\n任何题的情况下，小花能够考S 分。《算法导论》中共有n 道题，刷第i 题能使她的期中考试成绩提升\nsi（si ≥0）。但与此同时，刷题会产生疲劳，进而影响考试发挥，如果小花一共刷了k 道题，则她会因\n为疲劳而损失αk 分（α ≥0）。小花不喜欢跳着刷题，也不喜欢倒着刷题，更不喜欢重复刷题，因此她\n只会从某一题开始刷连续的若干题。假设小花希望让自己的最终分数落入[l,r]，请问她有多少种刷题\n方案？试设计一个具有O(nlgn) 最坏时间复杂度的算法解决该问题。（在小花所处的平行世界中，考试\n的分数未必是0 ∼100 的整数，因此你不能使用计数排序等对数据范围有限制的方法）\n解：令Dk = ∑k\ni=1 si −αk，当小花刷题的范围是(x,y] 时，她的最终得分为S+Dy −Dx。因此问题可\n转化为：满足x < y且Dy −Dx ∈[l −S,r −S] 的数对⟨x,y⟩的个数。与逆序对数量类似，这可以在归并排\n序的过程中顺便统计，或者通过维护一棵红黑树进行统计。详见区间和的个数\n", "answersPage": 9, "questionMarkdown": "小花不刷题时能够考 $S$ 分。《算法导论》共有 $n$ 道题，刷第 $i$ 题能使分数提升 $s_i$（$s_i\\ge0$）。若一共刷了 $k$ 道题，则因疲劳损失 $\\alpha k$ 分（$\\alpha\\ge0$）。\n\n她只会从某一题开始，按顺序刷连续的若干题，不跳题、不倒序、不重复。若希望最终分数落入 $[l,r]$，有多少种刷题方案？\n\n设计一个最坏时间复杂度为 $O(n\\lg n)$ 的算法。分数不一定是 $0\\sim100$ 的整数，因此不能使用计数排序等限制数据范围的方法。", "answerMarkdown": "定义前缀量 $D_0=0$，以及\n$$D_k=\\sum_{i=1}^{k}s_i-\\alpha k.$$\n刷题范围为 $(x,y]$ 时，最终得分为 $S+D_y-D_x$。于是问题转为统计\n$$0\\le x小花不刷题时能够考 SSS 分。《算法导论》共有 nnn 道题，刷第 iii 题能使分数提升 sis_isi​（si≥0s_i\\ge0si​≥0）。若一共刷了 kkk 道题，则因疲劳损失 αk\\alpha kαk 分（α≥0\\alpha\\ge0α≥0）。

\n

她只会从某一题开始，按顺序刷连续的若干题，不跳题、不倒序、不重复。若希望最终分数落入 [l,r][l,r][l,r]，有多少种刷题方案？

\n

设计一个最坏时间复杂度为 O(nlg⁡n)O(n\\lg n)O(nlgn) 的算法。分数不一定是 0∼1000\\sim1000∼100 的整数，因此不能使用计数排序等限制数据范围的方法。

\n", "answerHtml": "

定义前缀量 D0=0D_0=0D0​=0，以及

\nDk=∑i=1ksi−αk.D_k=\\sum_{i=1}^{k}s_i-\\alpha k.Dk​=i=1∑k​si​−αk.\n

刷题范围为 (x,y](x,y](x,y] 时，最终得分为 S+Dy−DxS+D_y-D_xS+Dy​−Dx​。于是问题转为统计

\n0≤x<y≤n,l−S≤Dy−Dx≤r−S0\\le x<y\\le n,\\qquad l-S\\le D_y-D_x\\le r-S0≤x<y≤n,l−S≤Dy​−Dx​≤r−S\n

的数对数目。

\n

可用归并排序计数：按原下标将前缀数组分为左右两半，递归统计内部合法对；合并前对已排序的两半，用两个单调指针统计每个左半值在右半中满足差值区间的数量；再完成归并。每层 O(n)O(n)O(n)，共 O(lg⁡n)O(\\lg n)O(lgn) 层，总时间 O(nlg⁡n)O(n\\lg n)O(nlgn)，辅助空间 O(n)O(n)O(n)。

\n

这里按原解统计非空连续段。若把“不刷任何题”也算一种方案，当 S∈[l,r]S\\in[l,r]S∈[l,r] 时再加 111。

\n" }, { "id": "2024-judge-1", "year": 2024, "type": "judge", "number": 1, "title": "主定理：平方根代价", "tags": [ "递归与复杂度" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2024-judge-1-paper-1.webp" ], "paperText": "1. (T,\nF) 递归式T(n) = 2T(n/5)+√n 的解满足T(n) = Θ\n(\nnlog52)\n。\n", "paperPage": 1, "answers": [ "assets/2024-judge-1-answers-1.webp" ], "answersText": "1. (T,\nF) 递归式T(n) = 2T(n/5)+√n 的解满足T(n) = Θ\n(\nnlog52)\n。\nF 错误。\n由主定理可得，对于ε = 0.5−log52 有f(n) = Ω(nlog52+ε)，则T(n) = Θ(√n)。\n", "answersPage": 1, "questionMarkdown": "递归式 $T(n)=2T(n/5)+\\sqrt n$ 的解满足 $T(n)=\\Theta(n^{\\log_5 2})$。", "answerMarkdown": "**F，错误。** 因为 $\\log_5 2<1/2$，$\\sqrt n$ 多项式级地大于 $n^{\\log_5 2}$；且 $2\\sqrt{n/5}=(2/\\sqrt5)\\sqrt n$ 满足正则条件，所以 $T(n)=\\Theta(\\sqrt n)$。", "questionHtml": "

递归式 T(n)=2T(n/5)+nT(n)=2T(n/5)+\\sqrt nT(n)=2T(n/5)+n​ 的解满足 T(n)=Θ(nlog⁡52)T(n)=\\Theta(n^{\\log_5 2})T(n)=Θ(nlog5​2)。

\n", "answerHtml": "

F，错误。 因为 log⁡52<1/2\\log_5 2<1/2log5​2<1/2，n\\sqrt nn​ 多项式级地大于 nlog⁡52n^{\\log_5 2}nlog5​2；且 2n/5=(2/5)n2\\sqrt{n/5}=(2/\\sqrt5)\\sqrt n2n/5​=(2/5​)n​ 满足正则条件，所以 T(n)=Θ(n)T(n)=\\Theta(\\sqrt n)T(n)=Θ(n​)。

\n" }, { "id": "2024-judge-2", "year": 2024, "type": "judge", "number": 2, "title": "建堆的时间复杂度", "tags": [ "堆", "排序" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2024-judge-2-paper-1.webp" ], "paperText": "2. (T,\nF) 堆排序是一种不稳定的排序算法，给长度为n 的数组A 建立最大堆的时间复杂度为\nΘ(nlogn) 。\n", "paperPage": 1, "answers": [ "assets/2024-judge-2-answers-1.webp" ], "answersText": "2. (T,\nF) 堆排序是一种不稳定的排序算法，给长度为n 的数组A 建立最大堆的时间复杂度为\nΘ(nlogn) 。\nF 错误。\n给长度为n 的数组A 建立最大堆的时间复杂度为Θ(n)。\n", "answersPage": 1, "questionMarkdown": "堆排序是一种不稳定的排序算法，给长度为 $n$ 的数组 $A$ 建立最大堆的时间复杂度为 $\\Theta(n\\log n)$。", "answerMarkdown": "**F，错误。** 堆排序通常不稳定，但自底向上的 BUILD-MAX-HEAP 时间复杂度为 $\\Theta(n)$。不能把逐次插入建堆的上界当作该算法的复杂度。", "questionHtml": "

堆排序是一种不稳定的排序算法，给长度为 nnn 的数组 AAA 建立最大堆的时间复杂度为 Θ(nlog⁡n)\\Theta(n\\log n)Θ(nlogn)。

\n", "answerHtml": "

F，错误。 堆排序通常不稳定，但自底向上的 BUILD-MAX-HEAP 时间复杂度为 Θ(n)\\Theta(n)Θ(n)。不能把逐次插入建堆的上界当作该算法的复杂度。

\n" }, { "id": "2024-judge-3", "year": 2024, "type": "judge", "number": 3, "title": "插入排序的最后一趟", "tags": [ "排序" ], "points": 5, "correct": true, "note": "", "paper": [ "assets/2024-judge-3-paper-1.webp" ], "paperText": "3. (T,\nF) 插入排序在最后一趟开始之前，所有的元素可能都不在其最终的位置上。\n", "paperPage": 1, "answers": [ "assets/2024-judge-3-answers-1.webp" ], "answersText": "3. (T,\nF) 插入排序在最后一趟开始之前，所有的元素可能都不在其最终的位置上。\nT 正确。\n在插入排序中，如果待排序列中的最后一个元素其关键字值为最小，则在最后一趟开始之前，前\nn-1 个排好序的元素都不在其最终位置上，与排好序后的位置相差一个位置。\n", "answersPage": 1, "questionMarkdown": "插入排序在最后一趟开始之前，所有的元素可能都不在其最终的位置上。", "answerMarkdown": "**T，正确。** 例如初始数组为 $[2,3,\\ldots,n,1]$。最后一趟开始前，前 $n-1$ 个元素有序但都应向右移动一位，最后的 $1$ 则应移到第一位。", "questionHtml": "

插入排序在最后一趟开始之前，所有的元素可能都不在其最终的位置上。

\n", "answerHtml": "

T，正确。 例如初始数组为 [2,3,…,n,1][2,3,\\ldots,n,1][2,3,…,n,1]。最后一趟开始前，前 n−1n-1n−1 个元素有序但都应向右移动一位，最后的 111 则应移到第一位。

\n" }, { "id": "2024-judge-4", "year": 2024, "type": "judge", "number": 4, "title": "链表上的快速排序与归并排序", "tags": [ "排序" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2024-judge-4-paper-1.webp" ], "paperText": "4. (T,\nF) 在处理链表而不是数组的数据结构时，快速排序比归并排序更具有优势，因为它不需\n要额外的空间来进行合并。\n", "paperPage": 2, "answers": [ "assets/2024-judge-4-answers-1.webp" ], "answersText": "4. (T,\nF) 在处理链表而不是数组的数据结构时，快速排序比归并排序更具有优势，因为它不需\n要额外的空间来进行合并。\nF 错误。\n在链表中使用归并排序不需要额外空间进行合并。同时链表不支持随机访问，因此快速排序无法\n高效地在链表中选择基准和进行分区，归并排序在链表上更具有优势。\n", "answersPage": 1, "questionMarkdown": "在处理链表而不是数组的数据结构时，快速排序比归并排序更具有优势，因为它不需要额外的空间来进行合并。", "answerMarkdown": "**F，错误。** 链表归并可以直接重连指针，无须额外的线性合并数组。链表又不支持随机访问，因此题目给出的优势不成立。", "questionHtml": "

在处理链表而不是数组的数据结构时，快速排序比归并排序更具有优势，因为它不需要额外的空间来进行合并。

\n", "answerHtml": "

F，错误。 链表归并可以直接重连指针，无须额外的线性合并数组。链表又不支持随机访问，因此题目给出的优势不成立。

\n" }, { "id": "2024-judge-5", "year": 2024, "type": "judge", "number": 5, "title": "后序与中序遍历相同", "tags": [ "二叉搜索树" ], "points": 5, "correct": true, "note": "", "paper": [ "assets/2024-judge-5-paper-1.webp" ], "paperText": "5. (T,\nF) 某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无右孩子。\n", "paperPage": 2, "answers": [ "assets/2024-judge-5-answers-1.webp" ], "answersText": "5. (T,\nF) 某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无右孩子。\nT 正确。\n后序：L, R, root，中序：L, root, R，要想两个序列一样，一定无R。\n", "answersPage": 1, "questionMarkdown": "某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无右孩子。", "answerMarkdown": "**T，正确。** 在结点标识互异的通常约定下，后序为“左、右、根”，中序为“左、根、右”。若右子树非空，根的位置就不可能相同；对子树递归应用同样结论。", "questionHtml": "

某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无右孩子。

\n", "answerHtml": "

T，正确。 在结点标识互异的通常约定下，后序为“左、右、根”，中序为“左、根、右”。若右子树非空，根的位置就不可能相同；对子树递归应用同样结论。

\n" }, { "id": "2024-judge-6", "year": 2024, "type": "judge", "number": 6, "title": "红黑树的子树高度", "tags": [ "红黑树" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2024-judge-6-paper-1.webp" ], "paperText": "6. (T,\nF) 对于红黑树中的每一个结点x，x 的左子树和右子树的高度最多相差1。\n", "paperPage": 2, "answers": [ "assets/2024-judge-6-answers-1.webp" ], "answersText": "6. (T,\nF) 对于红黑树中的每一个结点x，x 的左子树和右子树的高度最多相差1。\nF 错误。\n题述是二叉平衡树，红黑树每个结点左子树高度不会超过右子树高度的2 倍，右子树高度也不\n会超过左子树高度的2 倍。\n", "answersPage": 1, "questionMarkdown": "对于红黑树中的每一个结点 $x$，$x$ 的左子树和右子树的高度最多相差 $1$。", "answerMarkdown": "**F，错误。** 这是 AVL 树的高度平衡要求。红黑树约束黑高相等和红节点不相邻，并不要求左右子树普通高度差至多为 $1$。", "questionHtml": "

对于红黑树中的每一个结点 xxx，xxx 的左子树和右子树的高度最多相差 111。

\n", "answerHtml": "

F，错误。 这是 AVL 树的高度平衡要求。红黑树约束黑高相等和红节点不相邻，并不要求左右子树普通高度差至多为 111。

\n" }, { "id": "2024-short-1", "year": 2024, "type": "short", "number": 1, "title": "加权递归式的渐近上界", "tags": [ "递归与复杂度" ], "points": 10, "correct": null, "note": "答案按内容配对：本题对应答案卷“简答题第 3 题”，不是第 1 题。原解给出的上界为 O((lg n)²)。", "paper": [ "assets/2024-short-1-paper-1.webp" ], "paperText": "1. 对于递归式T(n) = T(n/3)/2+T(2n/3)/2+lgn, 请给出一个好的渐近上界，并用代入法验证。\n", "paperPage": 2, "answers": [ "assets/2024-short-1-answers-1.webp", "assets/2024-short-1-answers-2.webp" ], "answersText": "3. 对于递归式T(n) = T(n/3)/2+T(2n/3)/2+lgn, 请给出一个好的渐近上界，并用代入法验证。\n\n解：\n每一层的代价可以表示为1\n2i lg\n3i−1−1\n2\nn2i\n32i\n, 简单放缩后得到每层的代价约为O(lgn)，因此估计它的\n渐近上界为O(lg2n)，用代入法验证：\nT(n) = T(n/3)/2+T(2n/3)/2+lgn\n= 1\n2c(lg2(n/3))+ 1\n2c(lg2(2n/3))+lgn\n= clg2 n+(−lg3+lg2/3+(1/c))clgn+((1/2)lg2 3+(1/2)lg2(2/3))c (c > 1/(lg3+lg(3/2))\n≤clg2 n\n其中，常数项C = ((1/2)lg2 3+(1/2)lg2(2/3))c 被省略。\n同时，使用Akra-Bazzi 方法也可以求出该解。\n", "answersPage": 2, "questionMarkdown": "对于递归式\n$$T(n)=\\frac12T(n/3)+\\frac12T(2n/3)+\\lg n,$$\n请给出一个好的渐近上界，并用代入法验证。", "answerMarkdown": "配套答案给出上界 $O((\\lg n)^2)$。令 $L=\\lg n$，$a=\\lg3$，$b=\\lg(3/2)$，猜测 $T(n)\\le cL^2$。由归纳假设，\n$$\\begin{aligned}\nT(n)&\\le\\frac c2(L-a)^2+\\frac c2(L-b)^2+L\\\\\n&=cL^2+[1-c(a+b)]L+\\frac c2(a^2+b^2).\n\\end{aligned}$$\n选择 $c>1/(a+b)$，则对充分大的 $n$，后两项之和非正。放大常数并处理有限个基例，得 $T(n)=O((\\lg n)^2)$。\n\n本题在答案卷中位于“简答题第 3 题”，已按题目内容配对。", "questionHtml": "

对于递归式

\nT(n)=12T(n/3)+12T(2n/3)+lg⁡n,T(n)=\\frac12T(n/3)+\\frac12T(2n/3)+\\lg n,T(n)=21​T(n/3)+21​T(2n/3)+lgn,\n

请给出一个好的渐近上界，并用代入法验证。

\n", "answerHtml": "

配套答案给出上界 O((lg⁡n)2)O((\\lg n)^2)O((lgn)2)。令 L=lg⁡nL=\\lg nL=lgn，a=lg⁡3a=\\lg3a=lg3，b=lg⁡(3/2)b=\\lg(3/2)b=lg(3/2)，猜测 T(n)≤cL2T(n)\\le cL^2T(n)≤cL2。由归纳假设，

\nT(n)≤c2(L−a)2+c2(L−b)2+L=cL2+[1−c(a+b)]L+c2(a2+b2).\\begin{aligned}\nT(n)&\\le\\frac c2(L-a)^2+\\frac c2(L-b)^2+L\\\\\n&=cL^2+[1-c(a+b)]L+\\frac c2(a^2+b^2).\n\\end{aligned}T(n)​≤2c​(L−a)2+2c​(L−b)2+L=cL2+[1−c(a+b)]L+2c​(a2+b2).​\n

选择 c>1/(a+b)c>1/(a+b)c>1/(a+b)，则对充分大的 nnn，后两项之和非正。放大常数并处理有限个基例，得 T(n)=O((lg⁡n)2)T(n)=O((\\lg n)^2)T(n)=O((lgn)2)。

\n

本题在答案卷中位于“简答题第 3 题”，已按题目内容配对。

\n" }, { "id": "2024-short-2", "year": 2024, "type": "short", "number": 2, "title": "木块配对与容器分配", "tags": [ "双指针", "排序" ], "points": 10, "correct": null, "note": "答案按内容配对：本题对应答案卷“简答题第 1 题”。", "paper": [ "assets/2024-short-2-paper-1.webp" ], "paperText": "2. 有n 个木块，大小分别为a1,...,an ；另有m 个大小为V 的容器。定义一个容器被填满当且仅\n当其中放入了两个木块ai,aj ，且ai + aj ≤V 。每个木块只能使用一次。请给出时间复杂度为\nO(nlogn) 的算法来判断是否存在一种木块分配方案，使得这m 个容器都被填满。给出伪代码，\n并说明算法的工作原理。\n注意，你的算法不需要输出方案，只需要输出是或者否。\n", "paperPage": 3, "answers": [ "assets/2024-short-2-answers-1.webp" ], "answersText": "1. 有n 个木块，大小分别为a1,...,an ；另有m 个大小为V 的容器。定义一个容器被填满当且仅\n当其中放入了两个木块ai,aj ，且ai + aj ≤V 。每个木块只能使用一次。请给出时间复杂度为\nO(nlogn) 的算法来判断是否存在一种木块分配方案，使得这m 个容器都被填满。给出伪代码，\n并说明算法的工作原理。\n注意，你的算法不需要输出方案，只需要输出是或者否。\n解：\n先给a1,a2,...,an 排序，然后维护两个指针left,right 和一个计数器num 表示当前a1,a2,aleft 中\n有多少个木块没有被使用过，得到最多能够填满多少个容器。基本思想是：从大到小枚举right，\n对于目前最大的right ，找到使得aleft +aright ≤V 成立的最大left ，那么a1,a2,aleft 中没有用过\n的木块和aright 一起就都是一个合法的可以放到容器里的木块配对方案。如果这样的a1,a2,aleft\n存在，那么就任选一个和aright 配对。（这是因为：如果a1,a2,aleft 可以和aright 配对，那么也一\n定能和比aright 小的木块配对，且aright+1,...,an 的配对方案都已经决定过了，那么现在和aright\n配对一定是最优解之一。）之后num −−,right −−，前一个right 求出的left 值就可以作为初\n始值继续往上搜索下一个right 对应的left。直到right ≤left ，这表明剩下的num 个没有用到\n的木块都可以两两组合（这是因为上一轮的搜索保证了aleft +aright+1 ≤V），那么再给答案加上\n[ num\n2 ]。最后判断填满的容器数是否≥m 即可。\n时间复杂度：排序时间复杂度O(nlogn)，向内搜索时间复杂度O(n)，总时间复杂度O(nlogn)。\nAlgorithm 1 向内搜索\n1: sort a\n2: l = 0; r = n; num = 0; ans = 0;\n3: while l < r do\n4:\nwhile l +1 < r and al+1 +ar ≤V do\n5:\nl ++; num++;\n6:\nif num > 0 then\n7:\nnum−−; ans++;\n8:\nr −−;\n9: ans = ans+num/2;\n10:\n11: if ans ≥m then\n12:\nReturn True\n13: else\n14:\nReturn False\n", "answersPage": 2, "questionMarkdown": "有 $n$ 个木块，大小为 $a_1,\\ldots,a_n$；另有 $m$ 个大小为 $V$ 的容器。一个容器“被填满”当且仅当其中放入两个木块 $a_i,a_j$，且 $a_i+a_j\\le V$。每个木块只能使用一次。\n\n请给出 $O(n\\log n)$ 时间的算法，判断是否存在分配方案，使得这 $m$ 个容器都被填满。给出伪代码，说明原理；只输出是或否，不需要输出方案。", "answerMarkdown": "按原答案的排序与配对思路，可写成更简洁的双指针实现：\n\n```text\nCAN-FILL(a, n, m, V)\n sort a in nondecreasing order\n l = 1\n r = n\n pairs = 0\n while l < r\n if a[l] + a[r] <= V\n pairs = pairs + 1\n l = l + 1\n r = r - 1\n else\n r = r - 1\n return pairs >= m\n```\n\n若最小与最大木块之和大于 $V$，最大木块与任何剩余木块都不兼容，可舍弃。否则将它们配成一对不会降低最优配对数：在任意最优解中，通过交换伙伴可使这两个木块配对，而其余被替换的较小木块仍然兼容。\n\n排序为 $O(n\\log n)$，扫描为 $O(n)$，总时间 $O(n\\log n)$。对应答案卷“简答题第 1 题”。", "questionHtml": "

有 nnn 个木块，大小为 a1,…,ana_1,\\ldots,a_na1​,…,an​；另有 mmm 个大小为 VVV 的容器。一个容器“被填满”当且仅当其中放入两个木块 ai,aja_i,a_jai​,aj​，且 ai+aj≤Va_i+a_j\\le Vai​+aj​≤V。每个木块只能使用一次。

\n

请给出 O(nlog⁡n)O(n\\log n)O(nlogn) 时间的算法，判断是否存在分配方案，使得这 mmm 个容器都被填满。给出伪代码，说明原理；只输出是或否，不需要输出方案。

\n", "answerHtml": "

按原答案的排序与配对思路，可写成更简洁的双指针实现：

\n
CAN-FILL(a, n, m, V)\n    sort a in nondecreasing order\n    l = 1\n    r = n\n    pairs = 0\n    while l < r\n        if a[l] + a[r] <= V\n            pairs = pairs + 1\n            l = l + 1\n            r = r - 1\n        else\n            r = r - 1\n    return pairs >= m\n
\n

若最小与最大木块之和大于 VVV，最大木块与任何剩余木块都不兼容，可舍弃。否则将它们配成一对不会降低最优配对数：在任意最优解中，通过交换伙伴可使这两个木块配对，而其余被替换的较小木块仍然兼容。

\n

排序为 O(nlog⁡n)O(n\\log n)O(nlogn)，扫描为 O(n)O(n)O(n)，总时间 O(nlog⁡n)O(n\\log n)O(nlogn)。对应答案卷“简答题第 1 题”。

\n" }, { "id": "2024-short-3", "year": 2024, "type": "short", "number": 3, "title": "扩张红黑树：MIN-GAP", "tags": [ "红黑树", "数据结构扩张" ], "points": 10, "correct": null, "note": "答案按内容配对：本题对应答案卷“简答题第 2 题”。维护空子树时应使用 min = +∞、max = −∞、min_gap = +∞，避免访问不存在的关键字。", "paper": [ "assets/2024-short-3-paper-1.webp" ], "paperText": "3. 扩张红黑树使得它能以O(1) 的时间给出动态数集Q 中两个最接近的数之间的差值（MIN-GAP）。\n例如，Q = {1,5,9,15,18,22}，MIN-GAP 返回18−15 = 3，因为15 和18 是Q 中两个最接近的\n数。写出该数据结构并说明MIN-GAP 如何计算。\n", "paperPage": 3, "answers": [ "assets/2024-short-3-answers-1.webp" ], "answersText": "2. 扩张红黑树使得它能以O(1) 的时间给出动态数集Q 中两个最接近的数之间的差值（MIN-GAP）。\n例如，Q = {1,5,9,15,18,22}，MIN-GAP 返回18−15 = 3，因为15 和18 是Q 中两个最接近的\n数。写出该数据结构并说明MIN-GAP 如何计算。\n解：将红黑树的key 设为动态数集Q 中的值。结点x 的附加值包含以x 为根的子树中两\n个最接近的数之间的差值(x.min_gap)，以x 为根的子树中的最大值(x.max)，和以x 为\n根的子树中的最小值(x.min)。叶子结点的min_gap 设为∞，非叶子结点x 的x.min_gap =\nmin{x.left.min_gap,x.right.min_gap,x−x.left.max,x.right.min−x}。因此直接求根结点的min_gap\n即可在O(1) 的时间给出MIN-GAP。\n", "answersPage": 2, "questionMarkdown": "扩张红黑树，使其能以 $O(1)$ 时间给出动态数集 $Q$ 中两个最接近的数之间的差值 MIN-GAP。\n\n例如 $Q=\\{1,5,9,15,18,22\\}$ 时，返回 $18-15=3$。写出数据结构，并说明 MIN-GAP 如何计算。", "answerMarkdown": "以集合元素为红黑树关键字。在每个结点 $x$ 维护：子树最小值 $x.\\mathrm{min}$、最大值 $x.\\mathrm{max}$、最小相邻差 $x.\\mathrm{gap}$。\n\n设左右孩子分别为 $L,R$，则 $x.\\mathrm{gap}$ 为以下有效候选的最小值：\n\n- $L.\\mathrm{gap}$，$R.\\mathrm{gap}$；\n- 当 $L$ 非空时，$x.\\mathrm{key}-L.\\mathrm{max}$；\n- 当 $R$ 非空时，$R.\\mathrm{min}-x.\\mathrm{key}$。\n\n空子树及不足两个元素的子树，其最小差取 $+\\infty$。最小值、最大值也可由左右子树在 $O(1)$ 时间合并得到。\n\n插入、删除和旋转后维护这些属性，更新仍为 $O(\\log n)$。根结点的 `gap` 就是全局最小差，查询为 $O(1)$。对应答案卷“简答题第 2 题”。", "questionHtml": "

扩张红黑树，使其能以 O(1)O(1)O(1) 时间给出动态数集 QQQ 中两个最接近的数之间的差值 MIN-GAP。

\n

例如 Q={1,5,9,15,18,22}Q=\\{1,5,9,15,18,22\\}Q={1,5,9,15,18,22} 时，返回 18−15=318-15=318−15=3。写出数据结构，并说明 MIN-GAP 如何计算。

\n", "answerHtml": "

以集合元素为红黑树关键字。在每个结点 xxx 维护：子树最小值 x.minx.\\mathrm{min}x.min、最大值 x.maxx.\\mathrm{max}x.max、最小相邻差 x.gapx.\\mathrm{gap}x.gap。

\n

设左右孩子分别为 L,RL,RL,R，则 x.gapx.\\mathrm{gap}x.gap 为以下有效候选的最小值：

\n
    \n
  • L.gapL.\\mathrm{gap}L.gap，R.gapR.\\mathrm{gap}R.gap；
    • \n
  • 当 LLL 非空时，x.key−L.maxx.\\mathrm{key}-L.\\mathrm{max}x.key−L.max；
    • \n
  • 当 RRR 非空时，R.min−x.keyR.\\mathrm{min}-x.\\mathrm{key}R.min−x.key。
    • \n
\n

空子树及不足两个元素的子树，其最小差取 +∞+\\infty+∞。最小值、最大值也可由左右子树在 O(1)O(1)O(1) 时间合并得到。

\n

插入、删除和旋转后维护这些属性，更新仍为 O(log⁡n)O(\\log n)O(logn)。根结点的 gap 就是全局最小差，查询为 O(1)O(1)O(1)。对应答案卷“简答题第 2 题”。

\n" }, { "id": "2024-short-4", "year": 2024, "type": "short", "number": 4, "title": "斐波那契堆：抽取与级联切断", "tags": [ "斐波那契堆" ], "points": 10, "correct": null, "note": "", "paper": [ "assets/2024-short-4-paper-1.webp" ], "paperText": "4. 对于图一所给的斐波那契堆, 黑色节点表示结点的mark 属性为true:\n1) 抽取最小结点，画出操作后最后的结果（需要考虑CONSOLIDATE(合并) 操作，）。\n2) 在1）的基础上，把关键字为35 的节点的值降低为4, 画出操作后的最后的结果(需考虑\nCASCADING-CUT(级联切断) 操作)。\n5\n8\n3\n20\n12\n18\n30\n15\n45\n32\n35\n36\nH.min\n25\n9\n26\n27\n图1: 斐波那契堆\n", "paperPage": 4, "answers": [ "assets/2024-short-4-answers-1.webp", "assets/2024-short-4-answers-2.webp", "assets/2024-short-4-answers-3.webp" ], "answersText": "4. 对于图一所给的斐波那契堆, 黑色节点表示结点的mark 属性为true:\n1) 抽取最小结点，画出操作后最后的结果（需要考虑CONSOLIDATE(合并) 操作，）。\n2) 在1）的基础上，把关键字为35 的节点的值降低为4, 画出操作后的最后的结果(需考虑\nCASCADING-CUT(级联切断) 操作)。\n5\n8\n3\n20\n12\n18\n30\n15\n45\n32\n35\n36\nH.min\n25\n9\n26\n27\n图1: 斐波那契堆\n\n1)\n5\n3\n20\n12\n18\n30\n15\n45\n32\n35\n36\nH.min\n25\n9\n26\n5\n20\n12\n18\n30\n15\n45\n32\n35\n36\n25\n9\n26\n0\n1\n2\n3\n5\n20\n12\n18\n30\n15\n45\n32\n35\n36\n25\n9\n26\n0\n1\n2\n3\n5\n8\n20\n9\n18\n30\n15\n45\n32\n35\n36\n25\n26\n12\n0\n1\n2\n3\n9\n20\n5\n18\n12\n15\n45\n32\n35\n36\n25\n26\n30\n0\n1\n2\n3\n9\n8\n20\n5\n18\n12\n15\n45\n32\n35\n36\n25\n26\n30\n27\n27\n27\n27\n27\n27\n1）\n2）\n3）\n4）\n5）\n6）\n删除最小的节点，然后将最小节点的孩子全都放到根链表内\n发现度数为0的节点出现多次\n合并度数为0的节点，继续遍历，发现度数为1的节点出现多次\n合并度数为1的节点，继续遍历，发现度数为2的节点出现多次\n合并度数为2的节点，得到最终结果\n8\n8\n8\nH.min\nH.min\nH.min\nH.min\n由于节点8加入了别的节点，所以它的标记被清除了\n8\n\n2)\n9\n8\n20\n5\n18\n12\n15\n45\n32\n35\n36\n25\n26\n30\n27\nH.min\n9\n8\n20\n5\n18\n12\n15\n45\n32\n4\n36\n25\n26\n30\n27\nH.min\n9\n8\n20\n5\n18\n12\n15\n45\n32\n36\n25\n26\n30\n27\nH.min\n4\n9\n8\n20\n5\n18\n12\n15\n45\n32\n36\n25\n26\n30\n27\nH.min\n4\n1）\n2）\n3）\n4）\n将35减小为4\nCUT(4, 32)\n将节点4加入根链表\nCASCADING-CUT(H, 32)\n->CUT(H, 32, 20) -> CASCADING-CUT(H, 20)\n进行级联操作\n9\n8\n20\n5\n32\n12\n15\n45\n36\n18\n30\nH.min\n4\n5）\n25\n26\n27\n", "answersPage": 3, "questionMarkdown": "对于下图所给的斐波那契堆，黑色节点表示结点的 `mark` 属性为 `true`：\n\n1. 抽取最小结点，画出操作后的最终结果，需要考虑 CONSOLIDATE（合并）操作。\n2. 在第 1 问的基础上，把关键字 $35$ 减为 $4$，画出操作后的最终结果，需要考虑 CASCADING-CUT（级联切断）操作。\n\n{{QUESTION_DIAGRAM}}", "answerMarkdown": "**第 1 问：抽取最小结点。** 将最小结点的孩子加入根链表，删除最小结点，再反复合并度数相同的根。合并时较小关键字成为父节点，最后更新最小指针。\n\n{{ANSWER_DIAGRAM_1}}\n\n**第 2 问：降低关键字。** 将 $35$ 改为 $4$。若它小于父节点，则切断并加入根链表；对原父节点执行级联切断：未标记的非根结点先置标记，已标记的非根结点继续切断。移到根链表的结点清除标记，再更新最小指针。\n\n{{ANSWER_DIAGRAM_2}}\n\n上图保留配套答案中的结构示意。根链表顺序及同度根的合并顺序可以不同，应核对堆序、父子关系、度数、标记和最小指针。", "questionHtml": "

对于下图所给的斐波那契堆，黑色节点表示结点的 mark 属性为 true：

\n
    \n
  1. 抽取最小结点，画出操作后的最终结果，需要考虑 CONSOLIDATE（合并）操作。
    2. \n
  2. 在第 1 问的基础上，把关键字 353535 减为 444，画出操作后的最终结果，需要考虑 CASCADING-CUT（级联切断）操作。
    3. \n
\n
\"2024
原卷结构图 · 点击放大
\n", "answerHtml": "

第 1 问：抽取最小结点。 将最小结点的孩子加入根链表，删除最小结点，再反复合并度数相同的根。合并时较小关键字成为父节点，最后更新最小指针。

\n
\"2024
原卷结构图 · 点击放大
\n

第 2 问：降低关键字。 将 353535 改为 444。若它小于父节点，则切断并加入根链表；对原父节点执行级联切断：未标记的非根结点先置标记，已标记的非根结点继续切断。移到根链表的结点清除标记，再更新最小指针。

\n
\"2024
原卷结构图 · 点击放大
\n

上图保留配套答案中的结构示意。根链表顺序及同度根的合并顺序可以不同，应核对堆序、父子关系、度数、标记和最小指针。

\n" }, { "id": "2024-comprehensive-1", "year": 2024, "type": "comprehensive", "number": 1, "title": "QuickSelect 与平均比较次数", "tags": [ "选择算法", "概率分析", "伪代码" ], "points": 15, "correct": null, "note": "原答案采用每轮 n+1 次比较的计数口径，与题给 PARTITION 的 n−1 次关键字比较不一致。按题给伪代码，递推首项为 n−1，m=1 时 C(n,1)=2n−2H_n。复习时应先明确比较次数的定义。", "paper": [ "assets/2024-comprehensive-1-paper-1.webp" ], "paperText": "1. 快速排序\n(a) 假设不是对整个数组排序，而只要确定一个给定的n 个元素数列的第m 个最小者。修改快速排序\n算法实现这一目的，以避免为进行一次完全排序所需要的额外操作。填写QuickSelect 算法。\nAlgorithm 1 QUICKSORT(arr, low, high)\n1: if low < high then\n2:\npivotIndex = PARTITION(arr, low, high)\n3:\nQUICKSORT(arr, low, pivotIndex - 1)\n4:\nQUICKSORT(arr, pivotIndex + 1, high)\nAlgorithm 2 PARTITION(arr, low, high)\n1: pivot = arr[high]\n2: i = low - 1\n3: for j = low to high - 1 do\n4:\nif arr[j] <= pivot then\n5:\ni = i + 1\n6:\nSWAP(arr[i], arr[j])\n7: SWAP(arr[i + 1], arr[high])\n8: Return i + 1\nAlgorithm 3 QuickSelect(arr, low, high, m)\n1:\n2:\n3:\n4:\n5:\n6:\n7:\n8:\n9:\n10:\n11:\n12:\n13:\n(b) 给出QuickSelect 的平均键码比较次数Cnm 的递推形式表达式。\n(c) 当m = 1 时，计算Cn,1。\n", "paperPage": 5, "answers": [ "assets/2024-comprehensive-1-answers-1.webp", "assets/2024-comprehensive-1-answers-2.webp" ], "answersText": "1. 快速排序\n(a) 假设不是对整个数组排序，而只要确定一个给定的n 个元素数列的第m 个最小者。修改快速排序\n算法实现这一目的，以避免为进行一次完全排序所需要的额外操作。填写QuickSelect 算法。\nAlgorithm 2 QUICKSORT(arr, low, high)\n1: if low < high then\n2:\npivotIndex = PARTITION(arr, low, high)\n3:\nQUICKSORT(arr, low, pivotIndex - 1)\n4:\nQUICKSORT(arr, pivotIndex + 1, high)\nAlgorithm 3 PARTITION(arr, low, high)\n1: pivot = arr[high]\n2: i = low - 1\n3: for j = low to high - 1 do\n4:\nif arr[j] <= pivot then\n5:\ni = i + 1\n6:\nSWAP(arr[i], arr[j])\n7: SWAP(arr[i + 1], arr[high])\n8: Return i + 1\nAlgorithm 4 QuickSelect(arr, low, high, m)\n1:\n2:\n3:\n4:\n5:\n6:\n7:\n8:\n9:\n10:\n11:\n12:\n13:\n(b) 给出QuickSelect 的平均键码比较次数Cnm 的递推形式表达式。\n(c) 当m = 1 时，计算Cn,1。\n\n解：\n(a)\nAlgorithm 5 QuickSelect(arr, low, high, m)\n1: if low = high then\n2:\nReturn arr[low]\n3: pivotIndex = PARTITION(arr, low, high)\n4: k = pivotIndex - low + 1\n5: if m = k then\n6:\nReturn arr[pivotIndex]\n7: else if m < k then\n8:\nReturn QuickSelect(arr, low, pivotIndex - 1, m)\n9: else\n10:\nReturn QuickSelect(arr, pivotIndex + 1, high, m - k)\n(b) 递推式是C11 = 0 和当n > 1 时,\nCnm = n+1+ 1\nn( ∑\n1≤s 1 时，我们有：\nCn = n+1+ 1\nn\n∑\n1≤s≤n−1\nCs\n可得:\nnCn = n2 +n+\n∑\n1≤s≤n−1\nCs\n(n−1)Cn−1 = n2 −n+\n∑\n1≤s≤n−2\nCs\n两式相减:\nnCn −(n−1)Cn−1 = 2n+Cn−1\n得到:\nCn −Cn−1 = 2\n而C1 = 0 故Cn = 2n−2\n", "answersPage": 6, "questionMarkdown": "**快速排序**\n\n**(a)** 不对整个数组排序，而只确定一个含 $n$ 个元素的数列的第 $m$ 小元素。修改快速排序，避免完整排序的额外操作。根据下面的 QUICKSORT 和 PARTITION，填写 QuickSelect$(\\mathrm{arr},\\mathrm{low},\\mathrm{high},m)$。\n\n```text\nQUICKSORT(arr, low, high)\n if low < high\n pivotIndex = PARTITION(arr, low, high)\n QUICKSORT(arr, low, pivotIndex - 1)\n QUICKSORT(arr, pivotIndex + 1, high)\n\nPARTITION(arr, low, high)\n pivot = arr[high]\n i = low - 1\n for j = low to high - 1\n if arr[j] <= pivot\n i = i + 1\n SWAP(arr[i], arr[j])\n SWAP(arr[i + 1], arr[high])\n return i + 1\n\nQuickSelect(arr, low, high, m)\n // 在此补全算法\n```\n\n**(b)** 给出 QuickSelect 平均键码比较次数 $C_{n,m}$ 的递推表达式。\n\n**(c)** 当 $m=1$ 时，计算 $C_{n,1}$。", "answerMarkdown": "**(a)** 只递归处理含目标秩的那一侧。\n\n```text\nQUICKSELECT(arr, low, high, m)\n if low == high\n return arr[low]\n pivotIndex = PARTITION(arr, low, high)\n k = pivotIndex - low + 1\n if m == k\n return arr[pivotIndex]\n else if m < k\n return QUICKSELECT(arr, low, pivotIndex - 1, m)\n else\n return QUICKSELECT(arr, pivotIndex + 1, high, m - k)\n```\n\n**(b)** 假设枢轴的秩等概率分布。按题给 PARTITION，每次划分做 $n-1$ 次关键字比较，因此 $C_{1,1}=0$，且\n$$\\begin{aligned}\nC_{n,m}=n-1+\\frac1n\\Bigg(&\\sum_{s=1}^{m-1}C_{n-s,m-s}\\\\\n&+\\sum_{s=m+1}^{n}C_{s-1,m}\\Bigg).\n\\end{aligned}$$\n\n**(c)** 令 $C_n=C_{n,1}$，则\n$$C_n=n-1+\\frac1n\\sum_{s=1}^{n-1}C_s.$$\n将 $nC_n$ 与 $(n-1)C_{n-1}$ 相减，得到 $C_n-C_{n-1}=2-2/n$。从 $C_1=0$ 累加可得\n$$C_{n,1}=2n-2H_n,$$\n其中 $H_n=\\sum_{j=1}^{n}1/j$。\n\n**原答案差异：** 原答案写了划分代价 $n+1$，并给出 $2n-2$；该结果与它自己的递推在小规模基例处也不一致。这里明确采用题给伪代码的“关键字比较次数”口径，原文仍可在原卷中核对。", "questionHtml": "

快速排序

\n

(a) 不对整个数组排序，而只确定一个含 nnn 个元素的数列的第 mmm 小元素。修改快速排序，避免完整排序的额外操作。根据下面的 QUICKSORT 和 PARTITION，填写 QuickSelect(arr,low,high,m)(\\mathrm{arr},\\mathrm{low},\\mathrm{high},m)(arr,low,high,m)。

\n
QUICKSORT(arr, low, high)\n    if low < high\n        pivotIndex = PARTITION(arr, low, high)\n        QUICKSORT(arr, low, pivotIndex - 1)\n        QUICKSORT(arr, pivotIndex + 1, high)\n\nPARTITION(arr, low, high)\n    pivot = arr[high]\n    i = low - 1\n    for j = low to high - 1\n        if arr[j] <= pivot\n            i = i + 1\n            SWAP(arr[i], arr[j])\n    SWAP(arr[i + 1], arr[high])\n    return i + 1\n\nQuickSelect(arr, low, high, m)\n    // 在此补全算法\n
\n

(b) 给出 QuickSelect 平均键码比较次数 Cn,mC_{n,m}Cn,m​ 的递推表达式。

\n

(c) 当 m=1m=1m=1 时，计算 Cn,1C_{n,1}Cn,1​。

\n", "answerHtml": "

(a) 只递归处理含目标秩的那一侧。

\n
QUICKSELECT(arr, low, high, m)\n    if low == high\n        return arr[low]\n    pivotIndex = PARTITION(arr, low, high)\n    k = pivotIndex - low + 1\n    if m == k\n        return arr[pivotIndex]\n    else if m < k\n        return QUICKSELECT(arr, low, pivotIndex - 1, m)\n    else\n        return QUICKSELECT(arr, pivotIndex + 1, high, m - k)\n
\n

(b) 假设枢轴的秩等概率分布。按题给 PARTITION，每次划分做 n−1n-1n−1 次关键字比较，因此 C1,1=0C_{1,1}=0C1,1​=0，且

\nCn,m=n−1+1n(∑s=1m−1Cn−s,m−s+∑s=m+1nCs−1,m).\\begin{aligned}\nC_{n,m}=n-1+\\frac1n\\Bigg(&\\sum_{s=1}^{m-1}C_{n-s,m-s}\\\\\n&+\\sum_{s=m+1}^{n}C_{s-1,m}\\Bigg).\n\\end{aligned}Cn,m​=n−1+n1​(​s=1∑m−1​Cn−s,m−s​+s=m+1∑n​Cs−1,m​).​\n

(c) 令 Cn=Cn,1C_n=C_{n,1}Cn​=Cn,1​，则

\nCn=n−1+1n∑s=1n−1Cs.C_n=n-1+\\frac1n\\sum_{s=1}^{n-1}C_s.Cn​=n−1+n1​s=1∑n−1​Cs​.\n

将 nCnnC_nnCn​ 与 (n−1)Cn−1(n-1)C_{n-1}(n−1)Cn−1​ 相减，得到 Cn−Cn−1=2−2/nC_n-C_{n-1}=2-2/nCn​−Cn−1​=2−2/n。从 C1=0C_1=0C1​=0 累加可得

\nCn,1=2n−2Hn,C_{n,1}=2n-2H_n,Cn,1​=2n−2Hn​,\n

其中 Hn=∑j=1n1/jH_n=\\sum_{j=1}^{n}1/jHn​=∑j=1n​1/j。

\n

原答案差异： 原答案写了划分代价 n+1n+1n+1，并给出 2n−22n-22n−2；该结果与它自己的递推在小规模基例处也不一致。这里明确采用题给伪代码的“关键字比较次数”口径，原文仍可在原卷中核对。

\n" }, { "id": "2024-comprehensive-2", "year": 2024, "type": "comprehensive", "number": 2, "title": "Treap：唯一性、插入与叶子期望", "tags": [ "平衡树", "概率分析" ], "points": 15, "correct": null, "note": "", "paper": [ "assets/2024-comprehensive-2-paper-1.webp" ], "paperText": "2. 二叉搜索树一定程度上可以提高搜索效率，但在最坏情况下，仍需要O(n) 时间完成一次搜索。为\n此，有人提出了Treap 树结构，即二叉搜索树（tree）与最小堆（heap）的组合。具体而言，该树内的\n每个结点x 都有一个关键字值x.key，另外，还要为每个结点x 指定一个优先级x.priority（假设所有\n结点的优先级都是不同的，而且所有的关键字也是不同的）。Treap 树的结点被排列成让关键字遵循二\n叉搜索树的性质，且优先级遵循最小堆顺序性质：\n• 如果v 是u 的左孩子，则v.key < u.key。\n• 如果v 是u 的右孩子，则v.key > u.key。\n• 如果v 是u 的孩子，则v.priority > u.priority。\n(a) 给定一个由(关键字，优先级) 对组成的结点集合{(xi.key,xi.priority)|1 ≤i ≤n}，存在多少颗不同\n的Treap 树能表示这个集合。\n(b) 给出Treap-Insert(T,x) 的伪代码（可以调用Left-Rotate 和Right-Rotate）。\n(c) 假设Treap 树中各结点的优先级独立且均匀分布。求解n 结点Treap 树中的叶子节点的期望数量\nE(n)。\n", "paperPage": 6, "answers": [ "assets/2024-comprehensive-2-answers-1.webp" ], "answersText": "2. 二叉搜索树一定程度上可以提高搜索效率，但在最坏情况下，仍需要O(n) 时间完成一次搜索。为\n此，有人提出了Treap 树结构，即二叉搜索树（tree）与最小堆（heap）的组合。具体而言，该树内的\n每个结点x 都有一个关键字值x.key，另外，还要为每个结点x 指定一个优先级x.priority（假设所有\n结点的优先级都是不同的，而且所有的关键字也是不同的）。Treap 树的结点被排列成让关键字遵循二\n叉搜索树的性质，且优先级遵循最小堆顺序性质：\n• 如果v 是u 的左孩子，则v.key < u.key。\n• 如果v 是u 的右孩子，则v.key > u.key。\n• 如果v 是u 的孩子，则v.priority > u.priority。\n(a) 给定一个由(关键字，优先级) 对组成的结点集合{(xi.key,xi.priority)|1 ≤i ≤n}，存在多少颗不同\n的Treap 树能表示这个集合。\n(b) 给出Treap-Insert(T,x) 的伪代码（可以调用Left-Rotate 和Right-Rotate）。\n(c) 假设Treap 树中各结点的优先级独立且均匀分布。求解n 结点Treap 树中的叶子节点的期望数量\nE(n)。\n解：\n(a) 1\n(b)\nAlgorithm 6 Treap-Insert(T,x)\n1: key = x.key\n2: priority = x.priority\n3: if T is NULL then\n4:\nreturn NewNode(key, priority)\n5: if key < T.key then\n6:\nT.left = Treap-Insert(T.left, x)\n7:\nif T.left.priority < T.priority then\n8:\nT = Right-Rotate(T)\n9: else\n10:\nT.right = Treap-Insert(T.right, x)\n11:\nif T.right.priority < T.priority then\n12:\nT = Left-Rotate(T)\n13: return T\n(c) E(0) = 0, E(1) = E(2) = 1，E(3) = 4\n3，又有\nE(n) = 1\nn\nn−1\n∑\nk=0\n(E(k)+E(n−1−k))\n假设当1 < n ≤n0 时，E(n) = n+1\n3 ，则\nE(n0 +1) =\n1\nn0 +1\nn0\n∑\nk=0\n(E(k)+E(n0 +1−1−k))\n=\n1\nn0 +1(\nn0−2\n∑\nk=2\nk +1+n0 −k +1\n3\n)+\n2\nn0 +1(0+ n0 +1\n3\n+1+ n0\n3 ) = n0 +2\n3\n故n = n0 +1 时，E(n) = n+1\n3 。递推得，E(n) = n+1\n3 , (n > 1)。综上，\nE(n) =\n\n\n\nn+1\n3 ,\nn > 1\n1,\nn = 1\n0,\nn = 0\n", "answersPage": 8, "questionMarkdown": "二叉搜索树在最坏情况下仍需 $O(n)$ 时间搜索。Treap 是二叉搜索树（tree）与最小堆（heap）的组合：每个结点 $x$ 有互异的关键字 $x.\\mathrm{key}$ 和互异的优先级 $x.\\mathrm{priority}$，满足：\n\n- 若 $v$ 是 $u$ 的左孩子，则 $v.\\mathrm{key}u.\\mathrm{key}$；\n- 若 $v$ 是 $u$ 的孩子，则 $v.\\mathrm{priority}>u.\\mathrm{priority}$。\n\n**(a)** 给定结点集合 $\\{(x_i.\\mathrm{key},x_i.\\mathrm{priority})\\mid1\\le i\\le n\\}$，有多少棵不同的 Treap 能表示这个集合？\n\n**(b)** 给出 Treap-Insert$(T,x)$ 的伪代码，可调用 Left-Rotate 和 Right-Rotate。\n\n**(c)** 假设优先级独立且均匀分布，求 $n$ 结点 Treap 中叶子结点数的期望 $E(n)$。", "answerMarkdown": "**(a)** 恰有 $1$ 棵。优先级最小的结点必须为根；关键字将其余结点唯一地分到左右子树，再递归应用相同结论。\n\n**(b)**\n```text\nTREAP-INSERT(T, x)\n if T == NIL\n return x // x 的左右孩子初始化为 NIL\n if x.key < T.key\n T.left = TREAP-INSERT(T.left, x)\n if T.left.priority < T.priority\n T = RIGHT-ROTATE(T)\n else\n T.right = TREAP-INSERT(T.right, x)\n if T.right.priority < T.priority\n T = LEFT-ROTATE(T)\n return T\n```\n\n**(c)** 根的关键字秩均匀分布。对 $n\\ge2$，有\n$$E(n)=\\frac1n\\sum_{k=0}^{n-1}[E(k)+E(n-1-k)].$$\n基例 $E(0)=0$、$E(1)=1$。代入并归纳可得\n$$E(n)=\\begin{cases}0,&n=0,\\\\1,&n=1,\\\\(n+1)/3,&n\\ge2.\\end{cases}$$", "questionHtml": "

二叉搜索树在最坏情况下仍需 O(n)O(n)O(n) 时间搜索。Treap 是二叉搜索树（tree）与最小堆（heap）的组合：每个结点 xxx 有互异的关键字 x.keyx.\\mathrm{key}x.key 和互异的优先级 x.priorityx.\\mathrm{priority}x.priority，满足：

\n
    \n
  • 若 vvv 是 uuu 的左孩子，则 v.key<u.keyv.\\mathrm{key}<u.\\mathrm{key}v.key<u.key；
    • \n
  • 若 vvv 是 uuu 的右孩子，则 v.key>u.keyv.\\mathrm{key}>u.\\mathrm{key}v.key>u.key；
    • \n
  • 若 vvv 是 uuu 的孩子，则 v.priority>u.priorityv.\\mathrm{priority}>u.\\mathrm{priority}v.priority>u.priority。
    • \n
\n

(a) 给定结点集合 {(xi.key,xi.priority)∣1≤i≤n}\\{(x_i.\\mathrm{key},x_i.\\mathrm{priority})\\mid1\\le i\\le n\\}{(xi​.key,xi​.priority)∣1≤i≤n}，有多少棵不同的 Treap 能表示这个集合？

\n

(b) 给出 Treap-Insert(T,x)(T,x)(T,x) 的伪代码，可调用 Left-Rotate 和 Right-Rotate。

\n

(c) 假设优先级独立且均匀分布，求 nnn 结点 Treap 中叶子结点数的期望 E(n)E(n)E(n)。

\n", "answerHtml": "

(a) 恰有 111 棵。优先级最小的结点必须为根；关键字将其余结点唯一地分到左右子树，再递归应用相同结论。

\n

(b)

\n
TREAP-INSERT(T, x)\n    if T == NIL\n        return x  // x 的左右孩子初始化为 NIL\n    if x.key < T.key\n        T.left = TREAP-INSERT(T.left, x)\n        if T.left.priority < T.priority\n            T = RIGHT-ROTATE(T)\n    else\n        T.right = TREAP-INSERT(T.right, x)\n        if T.right.priority < T.priority\n            T = LEFT-ROTATE(T)\n    return T\n
\n

(c) 根的关键字秩均匀分布。对 n≥2n\\ge2n≥2，有

\nE(n)=1n∑k=0n−1[E(k)+E(n−1−k)].E(n)=\\frac1n\\sum_{k=0}^{n-1}[E(k)+E(n-1-k)].E(n)=n1​k=0∑n−1​[E(k)+E(n−1−k)].\n

基例 E(0)=0E(0)=0E(0)=0、E(1)=1E(1)=1E(1)=1。代入并归纳可得

\nE(n)={0,n=0,1,n=1,(n+1)/3,n≥2.E(n)=\\begin{cases}0,&n=0,\\\\1,&n=1,\\\\(n+1)/3,&n\\ge2.\\end{cases}E(n)=⎩⎨⎧​0,1,(n+1)/3,​n=0,n=1,n≥2.​\n" }, { "id": "2024-bonus-1", "year": 2024, "type": "bonus", "number": 1, "title": "股票价值区间与滑动窗口", "tags": [ "区间问题", "哈希与桶" ], "points": 10, "correct": null, "note": "原答案中的 k 应为窗口大小 W。桶宽 A+1 的“同桶即满足”判断需要价格和 A 为整数；题干只规定 ai>0。若为实数且 A>0，可取桶宽 A，检查本桶及相邻桶，并假设哈希操作期望 O(1)，得到期望 O(n)。A=0 时用窗口内精确值哈希判重。", "paper": [ "assets/2024-bonus-1-paper-1.webp" ], "paperText": "四、附加题（根据题目要求写出解答过程，共10 分）。\n小迪作为一名投资者，常常研究不同的投资策略。最近，他提出了“价值区间”分析法：给定某\n只股票在一定时间范围内的价格a = [a0,a1,...,an−1] (ai > 0)，区间大小W，以及价值差A，若存在\ni < j ∈[0,n−1]，且|i−j| ≤W，|ai −aj| ≤A，则称该股票存在“价值区间”(i, j)。\n例如，a = [1,3,5,10]，若W = 2，A = 2，则存在两个“价值区间”：(0,1)，(1,2)；若W = 2，A = 1，\n则不存在“价值区间”。\n请你为小迪设计一个时间复杂度为O(n) 的算法ValueRange，以判断给定的股票是否存在“价\n值区间”。给出算法的伪代码，并分析其时间复杂度。（输入：a，W，A；输出：True or False）\n", "paperPage": 7, "answers": [ "assets/2024-bonus-1-answers-1.webp" ], "answersText": "四、附加题（根据题目要求写出解答过程，共10 分）。\n小迪作为一名投资者，常常研究不同的投资策略。最近，他提出了“价值区间”分析法：给定某\n只股票在一定时间范围内的价格a = [a0,a1,...,an−1] (ai > 0)，区间大小W，以及价值差A，若存在\ni < j ∈[0,n−1]，且|i−j| ≤W，|ai −aj| ≤A，则称该股票存在“价值区间”(i, j)。\n例如，a = [1,3,5,10]，若W = 2，A = 2，则存在两个“价值区间”：(0,1)，(1,2)；若W = 2，A = 1，\n则不存在“价值区间”。\n请你为小迪设计一个时间复杂度为O(n) 的算法ValueRange，以判断给定的股票是否存在“价\n值区间”。给出算法的伪代码，并分析其时间复杂度。（输入：a，W，A；输出：True or False）\nAlgorithm 7 ValueRange(a,W,A)\n1: map = {}\n2: size = A+1\n3: for i = 0 to n−1 do\n4:\nidx = ⌊ai\nsize⌋\n5:\nif idx in map then\n6:\nreturn True\n7:\nl = idx−1\n8:\nr = idx+1\n9:\nif l in map and |ai −map[l]| ≤A then\n10:\nreturn True\n11:\nif r in map and |ai −map[r]| ≤A then\n12:\nreturn True\n13:\nmap[idx] = ai\n14:\nif i ≥k then\n15:\npop map[⌊ai−k\nsize ⌋]\n16: return False\n时间复杂度O(n)，空间复杂度O(k)。\n", "answersPage": 9, "questionMarkdown": "小迪提出股票“价值区间”分析法。给定价格序列 $a=[a_0,a_1,\\ldots,a_{n-1}]$（$a_i>0$），区间大小 $W$ 和价值差 $A$；若存在 $0\\le i= W\n erase buckets[floor(a[i - W] / width)]\n return False\n```\n\n处理当前值前，桶中包含前面距离不超过 $W$ 的值。若尚未找到合法对，一个桶至多保存一个候选值，因此移除过期值不会覆盖仍需保留的同桶值。\n\n**实数价格的条件：** 题干未规定整数。若 $A>0$ 为实数，可把桶宽改为 $A$，同桶差严格小于 $A$，相邻桶仍逐个检查；若 $A=0$，改用窗口内精确值的哈希判重。\n\n假设哈希操作期望为 $O(1)$，总期望时间 $O(n)$，空间 $O(\\min(n,W))$。一般哈希表不保证最坏线性时间。", "questionHtml": "

小迪提出股票“价值区间”分析法。给定价格序列 a=[a0,a1,…,an−1]a=[a_0,a_1,\\ldots,a_{n-1}]a=[a0​,a1​,…,an−1​]（ai>0a_i>0ai​>0），区间大小 WWW 和价值差 AAA；若存在 0≤i<j≤n−10\\le i<j\\le n-10≤i<j≤n−1，使得

\n∣i−j∣≤W,∣ai−aj∣≤A,|i-j|\\le W,\\qquad |a_i-a_j|\\le A,∣i−j∣≤W,∣ai​−aj​∣≤A,\n

则称存在“价值区间”(i,j)(i,j)(i,j)。

\n

例如 a=[1,3,5,10]a=[1,3,5,10]a=[1,3,5,10]，当 W=2,A=2W=2,A=2W=2,A=2 时有 (0,1)(0,1)(0,1) 和 (1,2)(1,2)(1,2)；当 W=2,A=1W=2,A=1W=2,A=1 时不存在。

\n

请设计时间复杂度为 O(n)O(n)O(n) 的 ValueRange 算法判断是否存在价值区间。给出伪代码并分析复杂度。输入为 a,W,Aa,W,Aa,W,A，输出 True 或 False。

\n", "answerHtml": "

采用滑动窗口和哈希桶。若价格和 AAA 是整数，取桶宽 A+1A+1A+1，则同桶的两个值一定满足差值要求；还需检查相邻桶。以下把原答案中的窗口变量 k 统一为 W。

\n
VALUE-RANGE(a, W, A)\n    if W < 1 or A < 0\n        return False\n    buckets = empty hash map\n    width = A + 1\n    for i = 0 to length(a) - 1\n        id = floor(a[i] / width)\n        if id in buckets\n            return True\n        if id - 1 in buckets\n            if abs(a[i] - buckets[id - 1]) <= A\n                return True\n        if id + 1 in buckets\n            if abs(a[i] - buckets[id + 1]) <= A\n                return True\n        buckets[id] = a[i]\n        if i >= W\n            erase buckets[floor(a[i - W] / width)]\n    return False\n
\n

处理当前值前，桶中包含前面距离不超过 WWW 的值。若尚未找到合法对，一个桶至多保存一个候选值，因此移除过期值不会覆盖仍需保留的同桶值。

\n

实数价格的条件： 题干未规定整数。若 A>0A>0A>0 为实数，可把桶宽改为 AAA，同桶差严格小于 AAA，相邻桶仍逐个检查；若 A=0A=0A=0，改用窗口内精确值的哈希判重。

\n

假设哈希操作期望为 O(1)O(1)O(1)，总期望时间 O(n)O(n)O(n)，空间 O(min⁡(n,W))O(\\min(n,W))O(min(n,W))。一般哈希表不保证最坏线性时间。

\n" }, { "id": "2025-judge-1", "year": 2025, "type": "judge", "number": 1, "title": "非等半递归式与主定理", "tags": [ "递归与复杂度" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2025-judge-1-paper-1.webp" ], "paperText": "1. (T,\nF) 递归式T(n) = 2T( 2n\n3 )+nlogn 的解满足T(n) = Θ\n(\nn2)\n。\n", "paperPage": 1, "answers": [ "assets/2025-judge-1-answers-1.webp" ], "answersText": "1. (T,\nF) 递归式T(n) = 2T( 2n\n3 )+nlogn 的解满足T(n) = Θ\n(\nn2)\n。\nF 错误。\n由主定理可得，对于ε = 1\n2 log 3\n2\n4\n3 有f(n) = O(n\nlog 3\n2\n2−ε) = O(n\n1+log 3\n2\n4\n3 −ε)，则T(n) = Θ(n\nlog 3\n2\n2)。\n", "answersPage": 1, "questionMarkdown": "递归式 $T(n)=2T(2n/3)+n\\log n$ 的解满足 $T(n)=\\Theta(n^2)$。", "answerMarkdown": "**F，错误。** 主定理给出 $T(n)=\\Theta(n^{\\log_{3/2}2})$，因为 $\\log_{3/2}2>1$，$n\\log n$ 比该幂函数多项式级地小。", "questionHtml": "

递归式 T(n)=2T(2n/3)+nlog⁡nT(n)=2T(2n/3)+n\\log nT(n)=2T(2n/3)+nlogn 的解满足 T(n)=Θ(n2)T(n)=\\Theta(n^2)T(n)=Θ(n2)。

\n", "answerHtml": "

F，错误。 主定理给出 T(n)=Θ(nlog⁡3/22)T(n)=\\Theta(n^{\\log_{3/2}2})T(n)=Θ(nlog3/2​2)，因为 log⁡3/22>1\\log_{3/2}2>1log3/2​2>1，nlog⁡nn\\log nnlogn 比该幂函数多项式级地小。

\n" }, { "id": "2025-judge-2", "year": 2025, "type": "judge", "number": 2, "title": "因子个数求和", "tags": [ "递归与复杂度" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2025-judge-2-paper-1.webp" ], "paperText": "2. (T,\nF) 记σ(n) 表示数字n 的因子个数，例如σ(6) = 4，因为1,2,3,6 都是6 的因子。那么\n∑n\ni=1 σ(i) 是Θ(n√n) 的。\n", "paperPage": 1, "answers": [ "assets/2025-judge-2-answers-1.webp" ], "answersText": "2. (T,\nF) 记σ(n) 表示数字n 的因子个数，例如σ(6) = 4，因为1,2,3,6 都是6 的因子。那么\n∑n\ni=1 σ(i) 是Θ(n√n) 的。\nF 错误。\n对于每个数字i，包含i 这个因子的数字有i,2i,3i,··· ,⌊n\ni ⌋i，一共⌊n\ni ⌋个，求和就是：\nn\n∑\ni=1\nn\ni = Θ(nlogn)\n等价于调和级数。\n", "answersPage": 1, "questionMarkdown": "记 $\\sigma(n)$ 表示数字 $n$ 的因子个数，例如 $\\sigma(6)=4$，因为 $1,2,3,6$ 都是 $6$ 的因子。那么 $\\sum_{i=1}^{n}\\sigma(i)$ 是 $\\Theta(n\\sqrt n)$ 的。", "answerMarkdown": "**F，错误。** 按因子计数可得 $\\sum_{i=1}^{n}\\sigma(i)=\\sum_{d=1}^{n}\\lfloor n/d\\rfloor$。利用调和级数，上下界分别为 $nH_n-n$ 和 $nH_n$，所以结果是 $\\Theta(n\\log n)$。", "questionHtml": "

记 σ(n)\\sigma(n)σ(n) 表示数字 nnn 的因子个数，例如 σ(6)=4\\sigma(6)=4σ(6)=4，因为 1,2,3,61,2,3,61,2,3,6 都是 666 的因子。那么 ∑i=1nσ(i)\\sum_{i=1}^{n}\\sigma(i)∑i=1n​σ(i) 是 Θ(nn)\\Theta(n\\sqrt n)Θ(nn​) 的。

\n", "answerHtml": "

F，错误。 按因子计数可得 ∑i=1nσ(i)=∑d=1n⌊n/d⌋\\sum_{i=1}^{n}\\sigma(i)=\\sum_{d=1}^{n}\\lfloor n/d\\rfloor∑i=1n​σ(i)=∑d=1n​⌊n/d⌋。利用调和级数，上下界分别为 nHn−nnH_n-nnHn​−n 和 nHnnH_nnHn​，所以结果是 Θ(nlog⁡n)\\Theta(n\\log n)Θ(nlogn)。

\n" }, { "id": "2025-judge-3", "year": 2025, "type": "judge", "number": 3, "title": "归并排序的稳定性与复杂度", "tags": [ "排序" ], "points": 5, "correct": true, "note": "试卷写的是 Θ(n log n)，答案卷复述为 O(n log n)；对标准归并排序，两者判断均为正确。", "paper": [ "assets/2025-judge-3-paper-1.webp" ], "paperText": "3. (T,\nF) 归并排序是稳定的，其时间复杂度在任何情况下都一定是Θ(nlogn)。\n", "paperPage": 1, "answers": [ "assets/2025-judge-3-answers-1.webp" ], "answersText": "3. (T,\nF) 归并排序是稳定的，其时间复杂度在任何情况下都一定是O(nlogn)。\nT 正确。\n均是归并排序的基本结论。\n", "answersPage": 1, "questionMarkdown": "归并排序是稳定的，其时间复杂度在任何情况下都一定是 $\\Theta(n\\log n)$。", "answerMarkdown": "**T，正确。** 对标准归并排序，稳定归并保证稳定性，每层合并代价为 $\\Theta(n)$，递归层数为 $\\Theta(\\log n)$。这里采用课程中标准实现的约定。", "questionHtml": "

归并排序是稳定的，其时间复杂度在任何情况下都一定是 Θ(nlog⁡n)\\Theta(n\\log n)Θ(nlogn)。

\n", "answerHtml": "

T，正确。 对标准归并排序，稳定归并保证稳定性，每层合并代价为 Θ(n)\\Theta(n)Θ(n)，递归层数为 Θ(log⁡n)\\Theta(\\log n)Θ(logn)。这里采用课程中标准实现的约定。

\n" }, { "id": "2025-judge-4", "year": 2025, "type": "judge", "number": 4, "title": "计数排序的空间复杂度", "tags": [ "排序" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2025-judge-4-paper-1.webp" ], "paperText": "4. (T,\nF) 计数排序(Counting Sort) 的空间复杂度是O(1)。\n", "paperPage": 2, "answers": [ "assets/2025-judge-4-answers-1.webp" ], "answersText": "4. (T,\nF) 计数排序(Counting Sort) 的空间复杂度是O(1)。\nF 错误。计数排序需要O(n+k) 的空间。\n", "answersPage": 1, "questionMarkdown": "计数排序（Counting Sort）的空间复杂度是 $O(1)$。", "answerMarkdown": "**F，错误。** 标准稳定计数排序需要计数数组和输出数组，辅助空间为 $O(n+k)$，其中 $k$ 为关键字范围大小。", "questionHtml": "

计数排序（Counting Sort）的空间复杂度是 O(1)O(1)O(1)。

\n", "answerHtml": "

F，错误。 标准稳定计数排序需要计数数组和输出数组，辅助空间为 O(n+k)O(n+k)O(n+k)，其中 kkk 为关键字范围大小。

\n" }, { "id": "2025-judge-5", "year": 2025, "type": "judge", "number": 5, "title": "两种遍历能否确定第三种", "tags": [ "二叉搜索树" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2025-judge-5-paper-1.webp" ], "paperText": "5. (T,\nF) 某二叉树的前序、中序、后序遍历中，任意给定两项，都可以唯一确定第三项。\n", "paperPage": 2, "answers": [ "assets/2025-judge-5-answers-1.webp" ], "answersText": "5. (T,\nF) 某二叉树的前序、中序、后序遍历中，任意给定两项，都可以唯一确定第三项。\nF 错误。\n只有前序和后序时无法确定中序遍历，例如前序是1,2，后序是2,1，此时无法确定2 是左儿子\n还是右儿子。\n", "answersPage": 1, "questionMarkdown": "某二叉树的前序、中序、后序遍历中，任意给定两项，都可以唯一确定第三项。", "answerMarkdown": "**F，错误。** 即使结点互异，前序和后序也不能唯一确定中序。例如前序为 $[1,2]$、后序为 $[2,1]$ 时，结点 $2$ 可以是根的左孩子，也可以是右孩子。", "questionHtml": "

某二叉树的前序、中序、后序遍历中，任意给定两项，都可以唯一确定第三项。

\n", "answerHtml": "

F，错误。 即使结点互异，前序和后序也不能唯一确定中序。例如前序为 [1,2][1,2][1,2]、后序为 [2,1][2,1][2,1] 时，结点 222 可以是根的左孩子，也可以是右孩子。

\n" }, { "id": "2025-judge-6", "year": 2025, "type": "judge", "number": 6, "title": "红黑树的节点数量上界", "tags": [ "红黑树" ], "points": 5, "correct": false, "note": "", "paper": [ "assets/2025-judge-6-paper-1.webp" ], "paperText": "6. (T,\nF) 对于一棵黑高为h 的红黑树，其内部节点（也就是有键值的点）的数量至多是2h+1 −1。\n", "paperPage": 2, "answers": [ "assets/2025-judge-6-answers-1.webp" ], "answersText": "6. (T\nF) 对于一棵黑高为h 的红黑树，其内部节点（也就是有键值的点）的数量至多是2h+1 −1。\nF 错误。\n至多为22h −1，构造从根开始黑红交替的满二叉树即可。\n", "answersPage": 1, "questionMarkdown": "对于一棵黑高为 $h$ 的红黑树，其内部节点（也就是有键值的点）的数量至多是 $2^{h+1}-1$。", "answerMarkdown": "**F，错误。** 在课程使用的黑高约定下，黑红逐层交替的满二叉树可有 $2^{2h}-1$ 个内部节点，超过题目给出的界。", "questionHtml": "

对于一棵黑高为 hhh 的红黑树，其内部节点（也就是有键值的点）的数量至多是 2h+1−12^{h+1}-12h+1−1。

\n", "answerHtml": "

F，错误。 在课程使用的黑高约定下，黑红逐层交替的满二叉树可有 22h−12^{2h}-122h−1 个内部节点，超过题目给出的界。

\n" }, { "id": "2025-short-1", "year": 2025, "type": "short", "number": 1, "title": "递归树与调和级数", "tags": [ "递归与复杂度" ], "points": 10, "correct": null, "note": "题干分母中的 log₂ n 表示以 2 为底的对数，不是 (log n)²。原解令 k≈log₂ n，最终结论可写为 Θ(n log log n)。", "paper": [ "assets/2025-short-1-paper-1.webp" ], "paperText": "1. 对于递归式T(n) = 2T( n\n2)+\nn\nlog2 n, 请给出渐近确界。\n", "paperPage": 2, "answers": [ "assets/2025-short-1-answers-1.webp" ], "answersText": "1. 对于递归式T(n) = 2T( n\n2)+\nn\nlog2 n, 请给出渐近确界。\n解:\nT(n) = 2T(n/2)+n/logn\n由于nlog2 2 = n，而f(n) = n/logn，此时主定理不适用。考虑递归树分析：\nT(n) = 2T(n/2)+\nn\nlogn\n= 4T(n/4)+\nn\nlogn +\nn\nlog n\n2\n= n\nlogn−1\n∑\ni=0\n1\nlog n\n2i\n假设存在整数k 使得2k ≤n < 2k+1。这意味着k ≤log2 n < k + 1，由于log2 n ≥k，我们有\nlog2 n−i ≥k −i。我们来分析求和部分S(n) = ∑k−1\ni=0\n1\nlog2 n−i 的上界：\nS(n) =\nk−1\n∑\ni=0\n1\nlog2 n−i ≤\nk−1\n∑\ni=0\n1\nk −i =\nk\n∑\nj=1\n1\nj = Hk\n其中Hk 是调和级数，我们知道Hk = Θ(logk)。所以，T(n) ≤n·Θ(logk) = O(nlogk)。而另一侧\n的下界同理，可以得到T(n) = Ω(nlogk)。综合得到T(n) = Θ(nlogk)。\n使用Akra-Bazzi 方法也可以求出该解, 具体解法可参照课本。\n", "answersPage": 2, "questionMarkdown": "对于递归式\n$$T(n)=2T\\!\\left(\\frac n2\\right)+\\frac{n}{\\log_2 n},$$\n请给出渐近确界。", "answerMarkdown": "这里 $\\log_2 n$ 表示以 $2$ 为底的对数。令 $n=2^k$，并令常数规模的递归终止代价为 $\\Theta(1)$。\n\n递归树第 $i$ 层的总非递归代价为 $n/(k-i)$，所以\n$$\\begin{aligned}\nT(n)&=\\Theta(n)+n\\sum_{i=0}^{k-1}\\frac1{k-i}\\\\\n&=\\Theta(n)+nH_k\\\\\n&=\\Theta(n\\log\\log n).\n\\end{aligned}$$\n其中 $H_k=\\Theta(\\log k)$。一般 $n$ 的上下界可用相邻的 $2$ 的幂夹逼。课程给出的主定理版本不能直接覆盖 $f(n)=n/\\log n$ 这一情形。", "questionHtml": "

对于递归式

\nT(n)=2T ⁣(n2)+nlog⁡2n,T(n)=2T\\!\\left(\\frac n2\\right)+\\frac{n}{\\log_2 n},T(n)=2T(2n​)+log2​nn​,\n

请给出渐近确界。

\n", "answerHtml": "

这里 log⁡2n\\log_2 nlog2​n 表示以 222 为底的对数。令 n=2kn=2^kn=2k，并令常数规模的递归终止代价为 Θ(1)\\Theta(1)Θ(1)。

\n

递归树第 iii 层的总非递归代价为 n/(k−i)n/(k-i)n/(k−i)，所以

\nT(n)=Θ(n)+n∑i=0k−11k−i=Θ(n)+nHk=Θ(nlog⁡log⁡n).\\begin{aligned}\nT(n)&=\\Theta(n)+n\\sum_{i=0}^{k-1}\\frac1{k-i}\\\\\n&=\\Theta(n)+nH_k\\\\\n&=\\Theta(n\\log\\log n).\n\\end{aligned}T(n)​=Θ(n)+ni=0∑k−1​k−i1​=Θ(n)+nHk​=Θ(nloglogn).​\n

其中 Hk=Θ(log⁡k)H_k=\\Theta(\\log k)Hk​=Θ(logk)。一般 nnn 的上下界可用相邻的 222 的幂夹逼。课程给出的主定理版本不能直接覆盖 f(n)=n/log⁡nf(n)=n/\\log nf(n)=n/logn 这一情形。

\n" }, { "id": "2025-short-2", "year": 2025, "type": "short", "number": 2, "title": "至少 k 种颜色的最短区间", "tags": [ "双指针", "区间问题" ], "points": 10, "correct": null, "note": "", "paper": [ "assets/2025-short-2-paper-1.webp" ], "paperText": "2. 有一排共n 桶染料，每桶燃料的颜色用一个[1,n] 之间的数字表示。画家小S 想要使用至少k 种\n颜色作画，但是他只能使用连续的若干桶染料（也就是若干桶相邻的染料）。现在请你求出：他\n最少需要用多少桶染料，才能够满足至少k 种颜色的要求。给出伪代码，并说明算法的工作原\n理。你的算法时间复杂度需要是O(n) 的，超出会酌情扣分。\n注意，你的算法不需要考虑无解的情况。\n", "paperPage": 3, "answers": [ "assets/2025-short-2-answers-1.webp", "assets/2025-short-2-answers-2.webp" ], "answersText": "2. 有一排共n 桶染料，每桶燃料的颜色用一个[1,n] 之间的数字表示。画家小S 想要使用至少k 种\n颜色作画，但是他只能使用连续的若干桶染料（也就是若干桶相邻的染料）。现在请你求出：他\n最少需要用多少桶染料，才能够满足至少k 种颜色的要求。给出伪代码，并说明算法的工作原\n理。你的算法时间复杂度需要是O(n) 的，超出会酌情扣分。\n注意，你的算法不需要考虑无解的情况。\n解：\n考虑使用双指针+ 桶计数。我们使用left 和right 维护一个滑动的窗口，也就是一个连续子数\n组[left...right]，同时用桶维护当前子数组中不同的颜色数量total。我们的目标是最小化这个区\n间的长度，也就是right −left +1。\n首先初始化left = 1,right = 0,total = 0,answer = n,cnt[] = 0，然后每一步中：\n• 不断向右扩展right，直到当前窗口包含k 种不同的颜色\n– cnt[color[r]] ←cnt[color[r]]+1，如果此时cnt[color[r]] 从0 变成1，说明出现了一种新\n的颜色，那么total ←total +1\n– r ←r +1，如果r > n，则退出循环\n• 更新答案answer ←min(answer,right −left +1)\n• cnt[color[l]] ←cnt[color[l]]−1，如果此时cnt[color[l]] 从1 变成0，说明将当前窗口右移一\n位后，少出现了一种颜色，那么total ←total −1\n• le ft ←left +1，表示窗口的左端点向右移动一步。\n\nAlgorithm 1 最短连续k 色子数组\nRequire: 颜色数组colors[1...n], 目标颜色数k\n1: n ←length of colors\n2: counts ←new array of size (n+1) initialized to 0\n3: le ft ←1\n4: right ←0\n5: total ←0\n6: answer ←n\n7: while le ft ≤n do\n8:\nwhile total < k and right < n do\n9:\nright ←right +1\n10:\ncright ←colors[right]\n11:\nif counts[cright] = 0 then\n12:\ntotal ←total +1\n13:\ncounts[cright] ←counts[cright]+1\n14:\nif total < k then\n15:\nbreak\n16:\nanswer ←min(answer,right −left +1)\n17:\ncleft ←colors[left]\n18:\ncounts[cle ft] ←counts[cle ft]−1\n19:\nif counts[cleft] = 0 then\n20:\ntotal ←total −1\n21:\nle ft ←left +1\n22: return answer\n", "answersPage": 2, "questionMarkdown": "有一排共 $n$ 桶染料，每桶颜色用 $[1,n]$ 之间的一个数字表示。画家小 S 想至少使用 $k$ 种颜色，但只能使用连续的若干桶染料。\n\n求满足至少 $k$ 种颜色要求时，最少需要使用多少桶。给出伪代码并说明原理，时间复杂度要求为 $O(n)$。不需要考虑无解情况。", "answerMarkdown": "用双指针维护窗口 $[\\mathrm{left},\\mathrm{right}]$，用 `counts` 记录每种颜色的出现次数，`total` 记录不同颜色数。右端点扩展到满足要求后，反复收缩左端并更新最小长度。\n\n```text\nSHORTEST-K-COLORS(colors, k)\n n = length(colors)\n counts[1..n] = 0\n left = 1\n total = 0\n answer = n\n for right = 1 to n\n c = colors[right]\n if counts[c] == 0\n total = total + 1\n counts[c] = counts[c] + 1\n while total >= k\n answer = min(answer, right - left + 1)\n c = colors[left]\n counts[c] = counts[c] - 1\n if counts[c] == 0\n total = total - 1\n left = left + 1\n return answer\n```\n\n每个元素最多进入和离开窗口各一次，时间复杂度为 $O(n)$，计数数组空间为 $O(n)$。该写法与原解的“先扩右端，再移左端”窗口思路等价，采用通常的 $1\\le k\\le n$ 约定。", "questionHtml": "

有一排共 nnn 桶染料，每桶颜色用 [1,n][1,n][1,n] 之间的一个数字表示。画家小 S 想至少使用 kkk 种颜色，但只能使用连续的若干桶染料。

\n

求满足至少 kkk 种颜色要求时，最少需要使用多少桶。给出伪代码并说明原理，时间复杂度要求为 O(n)O(n)O(n)。不需要考虑无解情况。

\n", "answerHtml": "

用双指针维护窗口 [left,right][\\mathrm{left},\\mathrm{right}][left,right]，用 counts 记录每种颜色的出现次数，total 记录不同颜色数。右端点扩展到满足要求后，反复收缩左端并更新最小长度。

\n
SHORTEST-K-COLORS(colors, k)\n    n = length(colors)\n    counts[1..n] = 0\n    left = 1\n    total = 0\n    answer = n\n    for right = 1 to n\n        c = colors[right]\n        if counts[c] == 0\n            total = total + 1\n        counts[c] = counts[c] + 1\n        while total >= k\n            answer = min(answer, right - left + 1)\n            c = colors[left]\n            counts[c] = counts[c] - 1\n            if counts[c] == 0\n                total = total - 1\n            left = left + 1\n    return answer\n
\n

每个元素最多进入和离开窗口各一次，时间复杂度为 O(n)O(n)O(n)，计数数组空间为 O(n)O(n)O(n)。该写法与原解的“先扩右端，再移左端”窗口思路等价，采用通常的 1≤k≤n1\\le k\\le n1≤k≤n 约定。

\n" }, { "id": "2025-short-3", "year": 2025, "type": "short", "number": 3, "title": "动态区间的最大重叠点", "tags": [ "红黑树", "数据结构扩张", "区间问题" ], "points": 10, "correct": null, "note": "区间端点相同时需要明确闭开约定。对闭区间，在同一坐标处先处理左端点的 +1，再处理右端点的 −1，才能正确统计端点处的重叠数。", "paper": [ "assets/2025-short-3-paper-1.webp" ], "paperText": "3. 已知在一个区间集合中，被最多数量区间覆盖的点被称为最大重叠点，且它一定可以是某个区间\n的端点。请你简述一个数据结构的设计思路，使它能够支持动态查询一个动态区间集合中的最大\n重叠点（任意一个符合要求的端点即可），并分析各操作的时间复杂度。\n提示：可将左端点关联+1 值，右端点关联-1 值。\n", "paperPage": 3, "answers": [ "assets/2025-short-3-answers-1.webp", "assets/2025-short-3-answers-2.webp" ], "answersText": "3. 已知在一个区间集合中，被最多数量区间覆盖的点被称为最大重叠点，且它一定可以是某个区间\n的端点。请你简述一个数据结构的设计思路，使它能够支持动态查询一个动态区间集合中的最大\n重叠点（任意一个符合要求的端点即可），并分析各操作的时间复杂度。\n解：\n利用扩展红黑树, 维护区间集合内的区间端点. 其中左端点权重为+1, 右端点权重为-1，任意位\n置的覆盖数量可以表示为从最左端点到该位置的权重前缀和。最大重叠点即为整个序列中权重\n前缀和的最大值所对应的端点。\n在红黑树中，每个节点存储以下三个辅助信息：\n• 子树权重和sum(x)：以该节点为根的子树中所有权重之和；\n• 最大前缀和max_prefix(x): 该子树内从最左端点出发可达到的最大前缀权重和；\n• 最大前缀位置argmax(x)：达到该最大前缀和的端点位置。\n当红黑树结构发生变化（如插入、删除或旋转）时，需要在回溯过程中重新计算每个受影响节点\n的辅助信息，即：\n首先计算该节点的子树权重和：等于左子树权重和+ 当前节点权重+ 右子树权重。\n然后计算最大前缀和：取三种可能的情形中的最大者：\n• 左子树内部的最大前缀和\n• 经过当前节点（左子树权重和+ 当前节点权重）\n• 跨过当前节点并延伸到右子树的最大前缀（左子树权重和+ 当前节点权重+ 右子树的最大\n前缀和）。\n与最大前缀和对应的位置argmax(x) 同步更新为产生该最大值的端点。\n因此，每当插入或删除一个区间的端点时，只需在回溯更新过程中依次执行上述“重新计算节点\n信息”的过程，复杂度为O(logn)\n\n最终，红黑树根节点的argmax 即为当前区间集合的最大重叠点，查询时间为O(1)\n", "answersPage": 3, "questionMarkdown": "在一个区间集合中，被最多数量区间覆盖的点称为最大重叠点，且它一定可以是某个区间的端点。\n\n简述一种数据结构，使其支持对动态区间集合查询最大重叠点（返回任意符合要求的端点即可），并分析各操作的时间复杂度。\n\n提示：可将左端点关联 $+1$ 值，右端点关联 $-1$ 值。", "answerMarkdown": "以端点为关键字建立扩张红黑树。左端点权重为 $+1$，右端点权重为 $-1$；扫描前缀权重和就是覆盖数。\n\n每个结点维护子树权重和 `sum`、最大非空前缀和 `max_prefix` 及其位置 `argmax`。设左右孩子为 $L,R$，当前权重为 $w$，则\n$$\\mathrm{sum}(x)=\\mathrm{sum}(L)+w+\\mathrm{sum}(R).$$\n最大前缀和取以下有效候选的最大值：\n\n1. $\\mathrm{max\\_prefix}(L)$；\n2. $\\mathrm{sum}(L)+w$；\n3. $\\mathrm{sum}(L)+w+\\mathrm{max\\_prefix}(R)$。\n\n同时保存最大值对应的端点。空子树的 `sum` 设为 $0$，其非空前缀候选忽略。\n\n插入或删除一个区间，需插入或删除两个端点，沿路径及旋转时每结点用 $O(1)$ 时间重算属性，总时间 $O(\\log n)$；查询根的 `argmax`，时间 $O(1)$。\n\n若为闭区间且坐标相同，必须先处理左端点再处理右端点；同类端点再用唯一编号区分，以正确处理重复端点。", "questionHtml": "

在一个区间集合中，被最多数量区间覆盖的点称为最大重叠点，且它一定可以是某个区间的端点。

\n

简述一种数据结构，使其支持对动态区间集合查询最大重叠点（返回任意符合要求的端点即可），并分析各操作的时间复杂度。

\n

提示：可将左端点关联 +1+1+1 值，右端点关联 −1-1−1 值。

\n", "answerHtml": "

以端点为关键字建立扩张红黑树。左端点权重为 +1+1+1，右端点权重为 −1-1−1；扫描前缀权重和就是覆盖数。

\n

每个结点维护子树权重和 sum、最大非空前缀和 max_prefix 及其位置 argmax。设左右孩子为 L,RL,RL,R，当前权重为 www，则

\nsum(x)=sum(L)+w+sum(R).\\mathrm{sum}(x)=\\mathrm{sum}(L)+w+\\mathrm{sum}(R).sum(x)=sum(L)+w+sum(R).\n

最大前缀和取以下有效候选的最大值：

\n
    \n
  1. max_prefix(L)\\mathrm{max\\_prefix}(L)max_prefix(L)；
    2. \n
  2. sum(L)+w\\mathrm{sum}(L)+wsum(L)+w；
    3. \n
  3. sum(L)+w+max_prefix(R)\\mathrm{sum}(L)+w+\\mathrm{max\\_prefix}(R)sum(L)+w+max_prefix(R)。
    4. \n
\n

同时保存最大值对应的端点。空子树的 sum 设为 000，其非空前缀候选忽略。

\n

插入或删除一个区间，需插入或删除两个端点，沿路径及旋转时每结点用 O(1)O(1)O(1) 时间重算属性，总时间 O(log⁡n)O(\\log n)O(logn)；查询根的 argmax，时间 O(1)O(1)O(1)。

\n

若为闭区间且坐标相同，必须先处理左端点再处理右端点；同类端点再用唯一编号区分，以正确处理重复端点。

\n" }, { "id": "2025-short-4", "year": 2025, "type": "short", "number": 4, "title": "斐波那契堆：抽取与级联切断", "tags": [ "斐波那契堆" ], "points": 10, "correct": null, "note": "", "paper": [ "assets/2025-short-4-paper-1.webp" ], "paperText": "4. 对于图一所给的斐波那契堆, 黑色节点表示结点的mark 属性为true:\n1) 抽取最小结点，画出操作后最后的结果(需要考虑CONSOLIDATE(合并) 操作)。\n2) 在1) 的基础上，把关键字为30 的节点的值降低为4, 画出操作后的最后的结果(需考虑\nCASCADING-CUT(级联切断) 操作)。\n7\n9\n6\n8\n16\n25\n3\n15\n20\n18\n36\n40\nH.min\n30\n45\n图1: 斐波那契堆\n", "paperPage": 4, "answers": [ "assets/2025-short-4-answers-1.webp", "assets/2025-short-4-answers-2.webp" ], "answersText": "4. 对于图一所给的斐波那契堆, 黑色节点表示结点的mark 属性为true:\n1) 抽取最小结点，画出操作后最后的结果（需要考虑CONSOLIDATE(合并) 操作，）。\n2) 在1) 的基础上，把关键字为30 的节点的值降低为4, 画出操作后的最后的结果(需考虑\nCASCADING-CUT(级联切断) 操作)。\n7\n9\n6\n8\n16\n25\n3\n15\n20\n18\n36\n40\nH.min\n30\n45\n图1: 斐波那契堆\n1)\n7\n9\n6\n8\n16\n25\n15\n20\n18\n36\n40\nH.min\n30\n45\n2)\n\n7\n9\n6\n8\n16\n25\n15\n18\n36\n40\nH.min\n45\n4\n20\n", "answersPage": 4, "questionMarkdown": "对于下图所给的斐波那契堆，黑色节点表示结点的 `mark` 属性为 `true`：\n\n1. 抽取最小结点，画出操作后的最终结果，需要考虑 CONSOLIDATE（合并）操作。\n2. 在第 1 问的基础上，把关键字 $30$ 减为 $4$，画出操作后的最终结果，需要考虑 CASCADING-CUT（级联切断）操作。\n\n{{QUESTION_DIAGRAM}}", "answerMarkdown": "**第 1 问：抽取最小结点。** 将最小结点的孩子加入根链表，删除最小结点，再反复合并度数相同的根。合并时较小关键字成为父节点，最后更新最小指针。\n\n{{ANSWER_DIAGRAM_1}}\n\n**第 2 问：降低关键字。** 将 $30$ 改为 $4$。若它小于父节点，则切断并加入根链表；对原父节点执行级联切断：未标记的非根结点先置标记，已标记的非根结点继续切断。移到根链表的结点清除标记，再更新最小指针。\n\n{{ANSWER_DIAGRAM_2}}\n\n上图保留配套答案中的结构示意。根链表顺序及同度根的合并顺序可以不同，应核对堆序、父子关系、度数、标记和最小指针。", "questionHtml": "

对于下图所给的斐波那契堆，黑色节点表示结点的 mark 属性为 true：

\n
    \n
  1. 抽取最小结点，画出操作后的最终结果，需要考虑 CONSOLIDATE（合并）操作。
    2. \n
  2. 在第 1 问的基础上，把关键字 303030 减为 444，画出操作后的最终结果，需要考虑 CASCADING-CUT（级联切断）操作。
    3. \n
\n
\"2025
原卷结构图 · 点击放大
\n", "answerHtml": "

第 1 问：抽取最小结点。 将最小结点的孩子加入根链表，删除最小结点，再反复合并度数相同的根。合并时较小关键字成为父节点，最后更新最小指针。

\n
\"2025
原卷结构图 · 点击放大
\n

第 2 问：降低关键字。 将 303030 改为 444。若它小于父节点，则切断并加入根链表；对原父节点执行级联切断：未标记的非根结点先置标记，已标记的非根结点继续切断。移到根链表的结点清除标记，再更新最小指针。

\n
\"2025
原卷结构图 · 点击放大
\n

上图保留配套答案中的结构示意。根链表顺序及同度根的合并顺序可以不同，应核对堆序、父子关系、度数、标记和最小指针。

\n" }, { "id": "2025-comprehensive-1", "year": 2025, "type": "comprehensive", "number": 1, "title": "计数排序与分组基数排序", "tags": [ "排序", "伪代码" ], "points": 15, "correct": null, "note": "", "paper": [ "assets/2025-comprehensive-1-paper-1.webp" ], "paperText": "1. 线性排序算法\n(a) 基数排序(Radix Sort) 的正确性依赖于一个稳定的子排序算法。假设我们使用计数排序(Counting\nSort) 作为RADIX-SORT 所需的稳定子排序算法STABLE-SORT，请写出COUNTING-SORT(A, d) 的伪代\n码，该算法用于对一个包含n 个元素的数组A 进行排序，其中每个元素都是不大于m 的非负整数。\nAlgorithm 1 COUNTING-SORT(A,m)\n1:\n2:\n3:\n4:\n5:\n6:\n7:\n8:\n9:\n10:\n11:\n12:\n13:\n14:\n(b) 已知待排序的n 个元素中的每一个都有d 位数字，且每一位数字都可以取0 到k −1 中的任意一\n个值（即最多有k 个可能的值），请推导出RADIX-SORT 的总时间复杂度。\n(c) 在实际应用中，我们经常处理b 位的二进制数。一种高效的策略是不按1 位排序，而是将b 位分\n成d 组，每组r 位（其中r ≤b）。我们对这d = ⌈b/r⌉组分别使用基数排序（同样使用计数排序作为\n子算法）。此时，RADIX-SORT 的总时间复杂度T(n,b,r) 是多少？\n", "paperPage": 5, "answers": [ "assets/2025-comprehensive-1-answers-1.webp" ], "answersText": "1. 线性排序算法\n(a) 基数排序(Radix Sort) 的正确性依赖于一个稳定的子排序算法。假设我们使用计数排序(Counting\nSort) 作为RADIX-SORT 所需的稳定子排序算法STABLE-SORT，请写出COUNTING-SORT(A, d) 的伪代\n码，该算法用于对一个包含n 个元素的数组A 进行排序，其中每个元素都是不大于m 的非负整数。\n解：\nAlgorithm 2 COUNTING-SORT(A, m)\n1: let B[0..n],C[0..m] be a new array\n2: for i = 0 to m do\n3:\nC[i] = 0\n4: for j = 1 to A.length do\n5:\nC[A[j]] = C[A[j]]+1\n6: for i = 1 to m do\n7:\nC[i] = C[i]+C[i−1]\n8: for j = A.length to 1 do\n9:\nB[C[A[j]]] = A[j]\n10:\nC[A[j]] = C[A[j]]−1\n11: Return B\n(b) 已知待排序的n 个元素中的每一个都有d 位数字，且每一位数字都可以取0 到k −1 中的任意一\n个值（即最多有k 个可能的值），请推导出RADIX-SORT 的总时间复杂度。\n解：\n1. RADIX-SORT 的核心是一个从1 到d 的for 循环。\n2. 循环体内部调用一次STABLE-SORT（即计数排序），其时间复杂度为Θ(n+k)。由于循环执行d\n次，总时间复杂度是d 次Θ(n+k) 的总和，即Θ(d(n+k))。\n(c) 在实际应用中，我们经常处理b 位的二进制数。一种高效的策略是不按1 位排序，而是将b 位分\n成d 组，每组r 位（其中r ≤b）。我们对这d = ⌈b/r⌉组分别使用基数排序（同样使用计数排序作为\n子算法）。此时，RADIX-SORT 的总时间复杂度T(n,b,r) 是多少？\n解：\n• 每次计数排序的时间复杂度变为Θ(n+k) = Θ(n+2r)。\n• 总共需要排序的“位数”d = ⌈b/r⌉。\n• 因此，总时间复杂度T(n,b,r) = Θ(d(n+2r)) = Θ(⌈b/r⌉(n+2r))。\n", "answersPage": 5, "questionMarkdown": "**线性排序算法**\n\n**(a)** 基数排序（Radix Sort）的正确性依赖稳定的子排序算法。使用计数排序（Counting Sort）作为稳定子排序算法，写出 COUNTING-SORT$(A,m)$ 的伪代码，对数组 $A$ 中的 $n$ 个元素排序，每个元素均为不大于 $m$ 的非负整数。\n\n原题文字处写作 COUNTING-SORT$(A,d)$，其后算法标题及关键字范围使用 $m$；这里按算法标题统一参数。\n\n**(b)** 待排序的 $n$ 个元素各有 $d$ 位数字，每一位可取 $0$ 至 $k-1$ 中任一值，推导 RADIX-SORT 总时间复杂度。\n\n**(c)** 对 $b$ 位二进制数，不按单比特排序，而将其分成 $d=\\lceil b/r\\rceil$ 组，每组至多 $r$ 位（$r\\le b$），逐组用计数排序。总时间复杂度 $T(n,b,r)$ 是多少？", "answerMarkdown": "**(a)**\n```text\nCOUNTING-SORT(A, m)\n n = length(A)\n let B[1..n] be a new array\n let C[0..m] be a new array\n for i = 0 to m\n C[i] = 0\n for j = 1 to n\n C[A[j]] = C[A[j]] + 1\n for i = 1 to m\n C[i] = C[i] + C[i - 1]\n for j = n downto 1\n B[C[A[j]]] = A[j]\n C[A[j]] = C[A[j]] - 1\n return B\n```\n\n逆序遍历输入数组写入输出，保证相同关键字的相对次序不变，因此稳定。\n\n**(b)** 每一位的计数排序为 $\\Theta(n+k)$，共 $d$ 位，故\n$$T=\\Theta\\bigl(d(n+k)\\bigr).$$\n\n**(c)** 每组最多 $r$ 位，关键字范围大小为 $2^r$，组数为 $\\lceil b/r\\rceil$，所以\n$$T(n,b,r)=\\Theta\\!\\left(\\left\\lceil\\frac br\\right\\rceil(n+2^r)\\right).$$", "questionHtml": "

线性排序算法

\n

(a) 基数排序（Radix Sort）的正确性依赖稳定的子排序算法。使用计数排序（Counting Sort）作为稳定子排序算法，写出 COUNTING-SORT(A,m)(A,m)(A,m) 的伪代码，对数组 AAA 中的 nnn 个元素排序，每个元素均为不大于 mmm 的非负整数。

\n

原题文字处写作 COUNTING-SORT(A,d)(A,d)(A,d)，其后算法标题及关键字范围使用 mmm；这里按算法标题统一参数。

\n

(b) 待排序的 nnn 个元素各有 ddd 位数字，每一位可取 000 至 k−1k-1k−1 中任一值，推导 RADIX-SORT 总时间复杂度。

\n

(c) 对 bbb 位二进制数，不按单比特排序，而将其分成 d=⌈b/r⌉d=\\lceil b/r\\rceild=⌈b/r⌉ 组，每组至多 rrr 位（r≤br\\le br≤b），逐组用计数排序。总时间复杂度 T(n,b,r)T(n,b,r)T(n,b,r) 是多少？

\n", "answerHtml": "

(a)

\n
COUNTING-SORT(A, m)\n    n = length(A)\n    let B[1..n] be a new array\n    let C[0..m] be a new array\n    for i = 0 to m\n        C[i] = 0\n    for j = 1 to n\n        C[A[j]] = C[A[j]] + 1\n    for i = 1 to m\n        C[i] = C[i] + C[i - 1]\n    for j = n downto 1\n        B[C[A[j]]] = A[j]\n        C[A[j]] = C[A[j]] - 1\n    return B\n
\n

逆序遍历输入数组写入输出，保证相同关键字的相对次序不变，因此稳定。

\n

(b) 每一位的计数排序为 Θ(n+k)\\Theta(n+k)Θ(n+k)，共 ddd 位，故

\nT=Θ(d(n+k)).T=\\Theta\\bigl(d(n+k)\\bigr).T=Θ(d(n+k)).\n

(c) 每组最多 rrr 位，关键字范围大小为 2r2^r2r，组数为 ⌈b/r⌉\\lceil b/r\\rceil⌈b/r⌉，所以

\nT(n,b,r)=Θ ⁣(⌈br⌉(n+2r)).T(n,b,r)=\\Theta\\!\\left(\\left\\lceil\\frac br\\right\\rceil(n+2^r)\\right).T(n,b,r)=Θ(⌈rb​⌉(n+2r)).\n" }, { "id": "2025-comprehensive-2", "year": 2025, "type": "comprehensive", "number": 2, "title": "顺序统计树与随机深度", "tags": [ "二叉搜索树", "数据结构扩张", "概率分析" ], "points": 15, "correct": null, "note": "", "paper": [ "assets/2025-comprehensive-2-paper-1.webp" ], "paperText": "2. 在标准二叉搜索树中，我们可以高效支持Search、Insert 和Delete 等操作，但无法高效处理\n顺序统计问题，如“第i 小的关键字是什么？”或者“关键字x 的排名是多少？”\n为解决此问题，我们引入顺序统计树（Order-Statistic Tree, OST）：它在每个结点x 中额外维护一\n个属性x.size，表示以x 为根的子树中包含的结点总数（包括x 自身）。空指针（记为NIL）的size\n定义为0。利用size 信息可实现OS-Select(x,i)，返回以x 为根的子树中第i 小的关键字对应的结\n点（1 ≤i ≤x.size）。\n(a) 在一棵OST 中，某结点x 满足x.left.size = 3，x.right.size = 5。\n1. 计算x.size。\n2. 若调用OS-Select(x,4)，将返回哪个结点？简要说明理由。\n(b) 用伪代码实现函数OS-Select(x,i)，其中x 是一棵OST 的根结点，i 为正整数。若1 ≤i ≤x.size，\n返回对应结点；否则返回NIL。\n(c) 假设OST 由关键字1,2,...,n 按均匀随机排列插入构建。令Di 表示第i 小关键字对应结点的深度\n（根深度为0）。\n1. 证明：对任意1 ≤i ≤n，\nE[Di] = Hi +Hn−i+1 −2,\n(提示：ln(k +1) ≤Hk ≤1+lnk\n对所有整数k ≥1 成立, 其中Hk = ∑k\nj=1\n1\nj 为第k 个调和数。)\n2. 利用(1) 的结论，推导OS-Select(T.root,i) 的时间复杂度。\n", "paperPage": 6, "answers": [ "assets/2025-comprehensive-2-answers-1.webp", "assets/2025-comprehensive-2-answers-2.webp" ], "answersText": "2. 在标准二叉搜索树中，我们可以高效支持Search、Insert 和Delete 等操作，但无法高效处理\n顺序统计问题，如“第i 小的关键字是什么？”或者“关键字x 的排名是多少？”\n为解决此问题，我们引入顺序统计树（Order-Statistic Tree, OST）：它在每个结点x 中额外维护一\n个属性x.size，表示以x 为根的子树中包含的结点总数（包括x 自身）。空指针（记为NIL）的size\n定义为0。利用size 信息可实现OS-Select(x,i)，返回以x 为根的子树中第i 小的关键字对应的结\n点（1 ≤i ≤x.size）。\n(a) 在一棵OST 中，某结点x 满足x.left.size = 3，x.right.size = 5。\n1. 计算x.size。\n2. 若调用OS-Select(x,4)，将返回哪个结点？简要说明理由。\n(b) 用伪代码实现函数OS-Select(x,i)，其中x 是一棵OST 的根结点，i 为正整数。若1 ≤i ≤x.size，\n返回对应结点；否则返回NIL。\n(c) 假设OST 由关键字1,2,...,n 按均匀随机排列插入构建。令Di 表示第i 小关键字对应结点的深度\n（根深度为0）。\n1. 证明：对任意1 ≤i ≤n，\nE[Di] = Hi +Hn−i+1 −2,\n(提示：ln(k +1) ≤Hk ≤1+lnk\n对所有整数k ≥1 成立, 其中Hk = ∑k\nj=1\n1\nj 为第k 个调和数。)\n2. 利用(1) 的结论，推导OS-Select(T.root,i) 的时间复杂度。\n解：(a)\n1. 由size 定义：\nx.size = x.left.size+x.right.size+1 = 3+5+1 = 9 .\n2. 设r = x.left.size + 1 = 3 + 1 = 4。根据OST 性质，x 是其子树中第r = 4 小的元素。因此，\nOS-Select(x,4) 返回结点x 自身。\n(b)\nAlgorithm 3 OS-SELECT(x, i)\nRequire: A node x and an integer i\n1: if x = NIL or i < 1 or i > x.size then\n2:\nreturn NIL\n3: end if\n4: if x.left = NIL then\n5:\nr ←1\n6: else\n7:\nr ←x.left.size+1\n8: end if\n9: if i = r then\n10:\nreturn x\n11: else if i < r then\n12:\nreturn OS-SELECT(x.left,i)\n13: else\n14:\nreturn OS-SELECT(x.right,i−r)\n15: end if\n(c)\n1. 证明：在随机BST 中，结点j ̸= i 是结点i 的祖先当且仅当在区间[min(i, j),max(i, j)] 中j 最先\n插入，故\nPr[j 是i 的祖先] =\n1\n|i−j|+1.\n\n深度Di 等于祖先个数，因此\nE[Di] =\ni−1\n∑\nj=1\n1\ni−j +1 +\nn\n∑\nj=i+1\n1\nj −i+1 =\ni\n∑\nk=2\n1\nk +\nn−i+1\n∑\nk=2\n1\nk = (Hi −1)+(Hn−i+1 −1) = Hi +Hn−i+1 −2.\n2. OS-Select(T.root,i) 访问Di + 1 个结点（深度为Di，路径含Di + 1 个结点），故运行时间\n= Di +1。取期望：\nE[time] = E[Di]+1 = Hi +Hn−i+1 +O(1).\n由于Hk ≤lnk +1，有\nE[Di]+1 ≤2(lni+ln(n−i+1))+O(1) ≤4lnn+O(1) = O(logn).\n因此，时间复杂度为O(logn)。\n", "answersPage": 6, "questionMarkdown": "标准二叉搜索树可支持 Search、Insert 和 Delete，但无法高效回答“第 $i$ 小的关键字是什么”或“关键字 $x$ 的排名是多少”。\n\n顺序统计树（Order-Statistic Tree，OST）在每个结点 $x$ 中维护 $x.\\mathrm{size}$，表示以 $x$ 为根的子树结点总数，包含 $x$ 自身。NIL 的 `size` 为 $0$。OS-Select$(x,i)$ 返回该子树中第 $i$ 小的结点。\n\n**(a)** 某结点满足 $x.\\mathrm{left}.\\mathrm{size}=3$，$x.\\mathrm{right}.\\mathrm{size}=5$：\n\n1. 计算 $x.\\mathrm{size}$。\n2. OS-Select$(x,4)$ 返回哪个结点？说明理由。\n\n**(b)** 写出 OS-Select$(x,i)$ 的伪代码。若 $1\\le i\\le x.\\mathrm{size}$，返回对应结点，否则返回 NIL。\n\n**(c)** 关键字 $1,2,\\ldots,n$ 按均匀随机排列依次插入，构造 OST。令 $D_i$ 为第 $i$ 小关键字结点的深度，根深度为 $0$。\n\n1. 证明\n$$\\mathbb E[D_i]=H_i+H_{n-i+1}-2.$$\n提示：$H_k=\\sum_{j=1}^{k}1/j$，且 $\\ln(k+1)\\le H_k\\le1+\\ln k$。\n2. 利用上式，推导 OS-Select$(T.\\mathrm{root},i)$ 的时间复杂度。", "answerMarkdown": "**(a)** $x.\\mathrm{size}=3+5+1=9$。$x$ 的子树内排名为左子树大小加 $1$，即 $4$，故 OS-Select$(x,4)$ 返回 $x$ 自身。\n\n**(b)**\n```text\nOS-SELECT(x, i)\n if x == NIL\n return NIL\n if i < 1 or i > x.size\n return NIL\n r = x.left.size + 1 // NIL.size = 0\n if i == r\n return x\n else if i < r\n return OS-SELECT(x.left, i)\n else\n return OS-SELECT(x.right, i - r)\n```\n\n**(c.1)** 对 $j\\ne i$，结点 $j$ 是 $i$ 的祖先，当且仅当在关键字区间 $[\\min(i,j),\\max(i,j)]$ 内，$j$ 最早插入。因此\n$$\\Pr[j\\text{ 是 }i\\text{ 的祖先}]=\\frac1{|i-j|+1}.$$\n利用期望的线性性，\n$$\\begin{aligned}\n\\mathbb E[D_i]&=\\sum_{j=1}^{i-1}\\frac1{i-j+1}\\\\\n&\\quad+\\sum_{j=i+1}^{n}\\frac1{j-i+1}\\\\\n&=(H_i-1)+(H_{n-i+1}-1).\n\\end{aligned}$$\n\n**(c.2)** 查找访问 $D_i+1$ 个结点，故\n$$\\mathbb E[\\mathrm{time}]=\\Theta(H_i+H_{n-i+1}-1)=\\Theta(\\log n)$$\n（$n\\ge2$）。这是随机构建假设下的期望复杂度，单棵退化树的最坏情况仍为 $O(n)$。", "questionHtml": "

标准二叉搜索树可支持 Search、Insert 和 Delete，但无法高效回答“第 iii 小的关键字是什么”或“关键字 xxx 的排名是多少”。

\n

顺序统计树（Order-Statistic Tree，OST）在每个结点 xxx 中维护 x.sizex.\\mathrm{size}x.size，表示以 xxx 为根的子树结点总数，包含 xxx 自身。NIL 的 size 为 000。OS-Select(x,i)(x,i)(x,i) 返回该子树中第 iii 小的结点。

\n

(a) 某结点满足 x.left.size=3x.\\mathrm{left}.\\mathrm{size}=3x.left.size=3，x.right.size=5x.\\mathrm{right}.\\mathrm{size}=5x.right.size=5：

\n
    \n
  1. 计算 x.sizex.\\mathrm{size}x.size。
    2. \n
  2. OS-Select(x,4)(x,4)(x,4) 返回哪个结点？说明理由。
    3. \n
\n

(b) 写出 OS-Select(x,i)(x,i)(x,i) 的伪代码。若 1≤i≤x.size1\\le i\\le x.\\mathrm{size}1≤i≤x.size，返回对应结点，否则返回 NIL。

\n

(c) 关键字 1,2,…,n1,2,\\ldots,n1,2,…,n 按均匀随机排列依次插入，构造 OST。令 DiD_iDi​ 为第 iii 小关键字结点的深度，根深度为 000。

\n
    \n
  1. 证明
    2. \n
\nE[Di]=Hi+Hn−i+1−2.\\mathbb E[D_i]=H_i+H_{n-i+1}-2.E[Di​]=Hi​+Hn−i+1​−2.\n

提示：Hk=∑j=1k1/jH_k=\\sum_{j=1}^{k}1/jHk​=∑j=1k​1/j，且 ln⁡(k+1)≤Hk≤1+ln⁡k\\ln(k+1)\\le H_k\\le1+\\ln kln(k+1)≤Hk​≤1+lnk。\n2. 利用上式，推导 OS-Select(T.root,i)(T.\\mathrm{root},i)(T.root,i) 的时间复杂度。

\n", "answerHtml": "

(a) x.size=3+5+1=9x.\\mathrm{size}=3+5+1=9x.size=3+5+1=9。xxx 的子树内排名为左子树大小加 111，即 444，故 OS-Select(x,4)(x,4)(x,4) 返回 xxx 自身。

\n

(b)

\n
OS-SELECT(x, i)\n    if x == NIL\n        return NIL\n    if i < 1 or i > x.size\n        return NIL\n    r = x.left.size + 1  // NIL.size = 0\n    if i == r\n        return x\n    else if i < r\n        return OS-SELECT(x.left, i)\n    else\n        return OS-SELECT(x.right, i - r)\n
\n

(c.1) 对 j≠ij\\ne ij=i，结点 jjj 是 iii 的祖先，当且仅当在关键字区间 [min⁡(i,j),max⁡(i,j)][\\min(i,j),\\max(i,j)][min(i,j),max(i,j)] 内，jjj 最早插入。因此

\nPr⁡[j 是 i 的祖先]=1∣i−j∣+1.\\Pr[j\\text{ 是 }i\\text{ 的祖先}]=\\frac1{|i-j|+1}.Pr[j 是 i 的祖先]=∣i−j∣+11​.\n

利用期望的线性性，

\nE[Di]=∑j=1i−11i−j+1+∑j=i+1n1j−i+1=(Hi−1)+(Hn−i+1−1).\\begin{aligned}\n\\mathbb E[D_i]&=\\sum_{j=1}^{i-1}\\frac1{i-j+1}\\\\\n&\\quad+\\sum_{j=i+1}^{n}\\frac1{j-i+1}\\\\\n&=(H_i-1)+(H_{n-i+1}-1).\n\\end{aligned}E[Di​]​=j=1∑i−1​i−j+11​+j=i+1∑n​j−i+11​=(Hi​−1)+(Hn−i+1​−1).​\n

(c.2) 查找访问 Di+1D_i+1Di​+1 个结点，故

\nE[time]=Θ(Hi+Hn−i+1−1)=Θ(log⁡n)\\mathbb E[\\mathrm{time}]=\\Theta(H_i+H_{n-i+1}-1)=\\Theta(\\log n)E[time]=Θ(Hi​+Hn−i+1​−1)=Θ(logn)\n

（n≥2n\\ge2n≥2）。这是随机构建假设下的期望复杂度，单棵退化树的最坏情况仍为 O(n)O(n)O(n)。

\n" }, { "id": "2025-bonus-1", "year": 2025, "type": "bonus", "number": 1, "title": "记忆碎片：受限交换的最小代价", "tags": [ "排序", "图与连通性" ], "points": 10, "correct": null, "note": "原解默认 k≥1。若允许 k=0，则只有原排列已经有序时答案为 0，其他情况无法完成排序。n<4 的情况可用 0–1 BFS 枚举排列求最小代价。", "paper": [ "assets/2025-bonus-1-paper-1.webp" ], "paperText": "四、附加题（根据题目要求写出解答过程，共10 分）。\n你得到了n 块按顺序排成一排的「记忆碎片」，第i 块碎片上记录的记忆发生时间为ti。已知\nt1,t2,...,tn 是1 ∼n 的一个排列，也就是说，这n 块碎片本来应该是按1,2,...,n 的时间顺序出现的，\n但现在被打乱了。你希望通过若干次交换操作，把这些碎片恢复成严格单调递增的顺序：\n(t1,t2,...,tn) −→(1,2,...,n).\n你拥有一个「回忆能力值」k。一次操作中，你可以任选两块碎片，设它们记忆的时间分别是x 和\ny，当且仅当|x−y| ≤k 时，你可以交换它们现在所在的位置。交换的体力消耗规则如下：\n• 若|x−y| = 1，也就是这两段记忆发生在相邻的两个时间点上，由于发生时间过于靠近的两块碎\n片很难回想，这次交换需要消耗你1 点精力；\n• 若2 ≤|x−y| ≤k，则这次交换不需要消耗精力，代价为0。\n你可以进行任意多次满足条件的交换操作。请你计算：为了将碎片恢复成(1,2,...,n)，你最少需要\n消耗多少点精力。\n设计时间复杂度尽可能小的算法。（输入：n，[t1,t2,...,tn]，k；输出：最少需要消耗的精力值）\n", "paperPage": 7, "answers": [ "assets/2025-bonus-1-answers-1.webp", "assets/2025-bonus-1-answers-2.webp" ], "answersText": "四、附加题（根据题目要求写出解答过程，共10 分）。\n你得到了n 块按顺序排成一排的「记忆碎片」，第i 块碎片上记录的记忆发生时间为ti。已知\nt1,t2,...,tn 是1 ∼n 的一个排列，也就是说，这n 块碎片本来应该是按1,2,...,n 的时间顺序出现的，\n但现在被打乱了。你希望通过若干次交换操作，把这些碎片恢复成严格单调递增的顺序：\n(t1,t2,...,tn) −→(1,2,...,n).\n你拥有一个「回忆能力值」k。一次操作中，你可以任选两块碎片，设它们记忆的时间分别是x 和\ny，当且仅当|x−y| ≤k 时，你可以交换它们现在所在的位置。交换的体力消耗规则如下：\n• 若|x−y| = 1，也就是这两段记忆发生在相邻的两个时间点上，由于发生时间过于靠近的两块碎\n片很难回想，这次交换需要消耗你1 点精力；\n• 若2 ≤|x−y| ≤k，则这次交换不需要消耗精力，代价为0。\n你可以进行任意多次满足条件的交换操作。请你计算：为了将碎片恢复成(1,2,...,n)，你最少需要\n消耗多少点精力。\n设计时间复杂度尽可能小的算法。（输入：n，[t1,t2,...,tn]，k；输出：最少需要消耗的精力值）\n解：下面分情况讨论。\n一、n < 4 的情况\n排列的状态总数不超过3! = 6 个。直接写出6 种排列的最优代价表。不再赘述。\n二、n ≥4 的情况\n(1) k = 1\n这是经典的“只用相邻数值换位”把一个排列排成升序，所需的最少此类交换次数等于\n这个排列的逆序对个数。形式化地，定义\ninv(t) = #{(i, j) | 1 ≤i < j ≤n, ti > tj}.\n那么当k = 1 时，答案就是\nans = inv(t) .\n可以用归并排序维护inv(t) 计数器, 可以在O(nlogn) 时间内统计。下面是算法：\n1. 若当前这段只剩下一个元素，则它本身已经有序，逆序对数为0。\n2. 否则，把当前这段分成长度尽量相等的左右两半，递归地分别对左半段、右半段做同样的处理，\n这一步会得到“左半段内部的逆序对数”和“右半段内部的逆序对数”，同时也会得到“排好序\n的左半段”和“排好序的右半段”。\n3. 接下来要把两个已经排好序的子段“像归并排序那样”合成一段有序的数组。合并时，左半段和\n右半段都从头开始往后看：\n\n• 如果左半段当前的数≤右半段当前的数，就先把左半段的这个数放进结果里，然后左半段\n指针后移；\n• 否则（也就是左半段当前的数> 右半段当前的数），说明右半段这个数应该排在当前左半\n段这个数以及左半段后面所有还没放进去的数的前面。由于左半段目前还没放进去的元素\n都是“比这个右半段元素大”的，所以这一时刻就一口气产生了“左半段当前还剩多少个元\n素”这么多个逆序对；把这个数量加到总答案里，再把右半段当前的数放进结果，然后右半\n段指针后移。\n4. 两边有一边先用完了，就把另一边剩下的所有元素按顺序接到结果后面；这一部分不会再产生新\n的逆序对。\n5. 当前这段的逆序对数= “左半段内部的逆序对数”+ “右半段内部的逆序对数”+ “合并时数\n到的那些跨左右的逆序对数”。\n(2) k = 2\n当|x−y| = 2 时交换免费；而差为2 的两个数一定同奇偶，于是：\n• 所有奇数记忆（1,3,5,...）之间可以免费任意重排；\n• 所有偶数记忆（2,4,6,...）之间也可以免费任意重排；\n• 想要把一个“奇数位置上却放了偶数”的错误修正，就必须和某个“偶数位置上却放了奇数”的\n错误做一次|x−y| = 1 的付费交换。\n目标序列(1,2,...,n) 在位置i 上的奇偶为i mod 2。统计原序列中奇偶不匹配的位置数：\nmism = #{i | (ti mod 2) ̸= (i mod 2)}.\n一条付费交换（交换一对差为1 的数，例如5 和6）会同时把一个“奇放偶位”的错误和一个“偶放\n奇位”的错误一起消掉，因此所需的付费次数正好是\nans = mism\n2\n.\n在n ≥4 的前提下，奇偶不匹配的个数一定是偶数，上式必为整数。该步骤只需线性时间O(n)。\n(3) k ≥3\n当能力值至少为3 时，我们既可以免费交换差为2 的一对（保持奇偶），也可以免费交\n换差为3 的一对（改变奇偶）；当n ≥4 时，可以证明任意一个数字都能通过若干次免费交换移动到任\n意位置，因此不需要做任何一次差为1 的付费交换，答案为\nans = 0 .\n", "answersPage": 7, "questionMarkdown": "有 $n$ 块按顺序排成一排的“记忆碎片”，第 $i$ 块记录时间为 $t_i$，$t_1,\\ldots,t_n$ 是 $1\\sim n$ 的一个排列。你希望通过交换恢复顺序：\n$$(t_1,t_2,\\ldots,t_n)\\longrightarrow(1,2,\\ldots,n).$$\n\n“回忆能力值”为 $k$。一次操作可选两块碎片，其时间为 $x,y$；当且仅当 $|x-y|\\le k$ 时，可以交换它们**当前所在的位置**。\n\n- 若 $|x-y|=1$，消耗 $1$ 点精力；\n- 若 $2\\le|x-y|\\le k$，代价为 $0$。\n\n可做任意多次合法交换，求恢复严格递增顺序所需的最小精力。设计时间复杂度尽可能小的算法。输入为 $n,[t_1,\\ldots,t_n],k$，输出最小代价。", "answerMarkdown": "**小规模：$n<4$。** 最多 $3!=6$ 个排列状态。以每种允许的交换作为代价 $0$ 或 $1$ 的边，在状态图上做 0–1 BFS，求到有序排列的最短距离。\n\n**当 $n\\ge4$ 时分情况：**\n\n**1. $k=1$。** 仅能交换相邻的数值，最少代价等于原排列的逆序对数：\n$$\\mathrm{ans}=\\#\\{(i,j):1\\le it_j\\}.$$\n可将操作视为在逆排列中交换相邻位置，而排列及其逆排列的逆序数相同。用归并排序统计，时间 $O(n\\log n)$。\n\n**2. $k=2$。** 差为 $2$ 的免费交换连通所有奇数，也连通所有偶数，因此可在每一类内部免费任意重排。设\n$$\\mathrm{mism}=\\#\\{i:(t_i\\bmod2)\\ne(i\\bmod2)\\}.$$\n每次付费交换最多修正两个奇偶错位；通过类内免费重排可让一对相邻数值处于需要交换的位置，因此该下界可达：\n$$\\mathrm{ans}=\\mathrm{mism}/2.$$\n时间为 $O(n)$。\n\n**3. $k\\ge3$。** 免费交换允许数值差为 $2$ 或 $3$。当 $n\\ge4$ 时，这些边连通全部数值（$1,2,3,4$ 已连通，其余可用差 $2$ 连入），连通图边交换可生成任意排列，因此答案为 $0$。\n\n**边界：** 若允许 $k=0$，没有合法交换；已排序时为 $0$，否则无法完成。原解默认 $k\\ge1$。", "questionHtml": "

有 nnn 块按顺序排成一排的“记忆碎片”，第 iii 块记录时间为 tit_iti​，t1,…,tnt_1,\\ldots,t_nt1​,…,tn​ 是 1∼n1\\sim n1∼n 的一个排列。你希望通过交换恢复顺序：

\n(t1,t2,…,tn)⟶(1,2,…,n).(t_1,t_2,\\ldots,t_n)\\longrightarrow(1,2,\\ldots,n).(t1​,t2​,…,tn​)⟶(1,2,…,n).\n

“回忆能力值”为 kkk。一次操作可选两块碎片，其时间为 x,yx,yx,y；当且仅当 ∣x−y∣≤k|x-y|\\le k∣x−y∣≤k 时，可以交换它们当前所在的位置。

\n
    \n
  • 若 ∣x−y∣=1|x-y|=1∣x−y∣=1，消耗 111 点精力；
    • \n
  • 若 2≤∣x−y∣≤k2\\le|x-y|\\le k2≤∣x−y∣≤k，代价为 000。
    • \n
\n

可做任意多次合法交换，求恢复严格递增顺序所需的最小精力。设计时间复杂度尽可能小的算法。输入为 n,[t1,…,tn],kn,[t_1,\\ldots,t_n],kn,[t1​,…,tn​],k，输出最小代价。

\n", "answerHtml": "

小规模：n<4n<4n<4。 最多 3!=63!=63!=6 个排列状态。以每种允许的交换作为代价 000 或 111 的边，在状态图上做 0–1 BFS，求到有序排列的最短距离。

\n

当 n≥4n\\ge4n≥4 时分情况：

\n

1. k=1k=1k=1。 仅能交换相邻的数值，最少代价等于原排列的逆序对数：

\nans=#{(i,j):1≤i<j≤n, ti>tj}.\\mathrm{ans}=\\#\\{(i,j):1\\le i<j\\le n,\\ t_i>t_j\\}.ans=#{(i,j):1≤i<j≤n, ti​>tj​}.\n

可将操作视为在逆排列中交换相邻位置，而排列及其逆排列的逆序数相同。用归并排序统计，时间 O(nlog⁡n)O(n\\log n)O(nlogn)。

\n

2. k=2k=2k=2。 差为 222 的免费交换连通所有奇数，也连通所有偶数，因此可在每一类内部免费任意重排。设

\nmism=#{i:(ti mod 2)≠(i mod 2)}.\\mathrm{mism}=\\#\\{i:(t_i\\bmod2)\\ne(i\\bmod2)\\}.mism=#{i:(ti​mod2)=(imod2)}.\n

每次付费交换最多修正两个奇偶错位；通过类内免费重排可让一对相邻数值处于需要交换的位置，因此该下界可达：

\nans=mism/2.\\mathrm{ans}=\\mathrm{mism}/2.ans=mism/2.\n

时间为 O(n)O(n)O(n)。

\n

3. k≥3k\\ge3k≥3。 免费交换允许数值差为 222 或 333。当 n≥4n\\ge4n≥4 时，这些边连通全部数值（1,2,3,41,2,3,41,2,3,4 已连通，其余可用差 222 连入），连通图边交换可生成任意排列，因此答案为 000。

\n

边界： 若允许 k=0k=0k=0，没有合法交换；已排序时为 000，否则无法完成。原解默认 k≥1k\\ge1k≥1。

\n" } ]