--- tags: - 算法设计与分析 - 试题 create time: 2026-06-10 10:00 --- # 试题 1 — 武汉科技大学《算法设计与分析》 ## 概述 - **课程**：算法设计与分析 - **学校**：武汉科技大学 - **题型**：单选题、简答题、代码分析题、算法设计与编程题 - **知识点**：算法复杂度分析、贪心算法、分治法、动态规划、回溯法、图算法 > [!tip] 学习建议 > 本试题包含代码分析和算法设计题，建议先理解各算法的核心思想，再对照代码验证。重点关注 **n皇后回溯** 和 **最大连续子数组和** 两个经典问题。 ## 正文 ### 一、单选题（每题2分，共10题，20分） **从备选的答案中选出合适的答案，并把答案标号写在答题纸中。** 1. 算法必须具备输入、输出和（ ）等四个特性。 - A. 可行性 - B. 程序代码 - C. 确定性 - D. 无限循环 2. 算法的复杂度包含（ ）两种。 - A. 空间复杂度和时间复杂度 - B. 最好复杂度和最坏复杂度 - C. 平均复杂度和最坏复杂度 - D. 最低复杂度和最高复杂度 3. 下列关于时间复杂度的说法中，一般认为哪个复杂度最高的是（ ）。 - A. O(logn) - B. O(n²) - C. O(n!) - D. O(n) 4. 斐波那契数列的递归实现时间复杂度是（ ）。 - A. O(n) - B. O(2ⁿ) - C. O(logn) - D. O(nlogn) 5. 在解决一个问题时，可以将问题划分成 k 个子问题，（ ）。 - A. 分治策略 - B. 贪心策略 - C. 动态规划策略 - D. 回溯策略 6. 哪些是图问题的优化算法可以在多项式时间实现（ ）。 - A. 最大流最小割算法 - B. 分支限界算法 - C. 贪心算法 - D. 广度优先算法 7. 以下关于回溯法的描述中，不正确的是（ ）。 - A. 回溯法一般用深度优先策略搜索解空间 - B. 回溯法适用于求解组合数较大的问题 - C. 回溯法的时间复杂度一般为 O(n!) - D. 回溯法在问题的解空间中按深度优先搜索 8. 有一个集合有 n 个元素，如果进行所有的子集的搜索，则当 n=10 时，最多搜索到的子集树的第（ ）层。 - A. 3 - B. 5 - C. 7 - D. 1 9. 分治法通常基于（ ）策略。 - A. 递归 - B. 迭代 - C. 贪心 - D. 动态规划 10. 设有一个递归算法 `int f(int n) { if(n<=1) return 1; else return f(n-1)+f(n-2); }`，计算 f(5) 需要调用（ ）次。 - A. 5 - B. 10 - C. 15 - D. 以上都不对 **参考答案：** | 题号 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | |------|---|---|---|---|---|---|---|---|---|---| | 答案 | C | A | C | B | A | B | B | B | A | A | > [!warning] 易错点 > 第4题：斐波那契递归实现的时间复杂度是 O(2ⁿ) 而非 O(n)。递归树是二叉树结构，每层展开2个分支，深度为 n，因此总调用次数为指数级。第10题 f(5) 的递归调用次数为 15 次。 > [!tip] 答题技巧 > 算法四要素：**有穷性、确定性、可行性、输入输出**。复杂度从低到高排序：O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(2ⁿ) < O(n!)。 --- ### 二、简答题（每题5分，共6题，30分） **要求：200字以内，不需配代码，不要配图。** #### 1. 中国剩余定理问题（10分） 有一堆苹果，3个3个地数，最后余2个；5个5个地数，最后余3个；7个7个地数，最后余2个。这堆苹果至少有多少个？ **参考答案：** 这是典型的中国剩余定理（孙子定理）问题。 设苹果数为 x，则： - x ≡ 2 (mod 3) - x ≡ 3 (mod 5) - x ≡ 2 (mod 7) 由条件1和条件3：x ≡ 2 (mod 3) 且 x ≡ 2 (mod 7)，因为 gcd(3,7)=1，所以 x ≡ 2 (mod 21)。 即 x = 21k + 2，代入条件2：21k + 2 ≡ 3 (mod 5) → k ≡ 1 (mod 5) 最小正整数解：k = 1，x = 21×1 + 2 = **23**。 > [!note] 教学提示 > 中国剩余定理的关键在于逐步合并同余方程。先找两个模数的最小公倍数，将两个条件合并为一个，再与第三个合并。 #### 2. 晋级赛问题 N人晋级赛，每人每轮淘汰一名对手。编号为1~N人进行一轮比赛，下一轮的比赛选手的编号规律是：1和N比赛，2和N-1比赛，3和N-2比赛，……。问晋级比赛的轮次和比赛场次。 **参考答案：** - 每轮比赛场次为 floor(N/2)，晋级人数为 ceil(N/2) - 配对规则：第 i 号与第 (N+1-i) 号对阵（对称配对） - 总比赛场次 = N - 1（每场淘汰1人） - 轮次 = ceil(log₂N) #### 3. 贪心算法框架 贪心算法的框架是什么？ **参考答案：** 贪心算法基本框架： 1. 从问题的初始解出发 2. 循环执行：从候选解集中选取当前最优的候选解 3. 若加入该候选解后解仍可行，则将其加入当前解 4. 重复直到达到目标或候选集为空 ```mermaid flowchart TD A["Start: Empty Solution"] --> B{"Candidate Set Empty?"} B -->|"No"| C["Select Best Candidate"] C --> D{"Solution Still Valid?"} D -->|"Yes"| E["Add to Solution"] E --> B D -->|"No"| F["Discard Candidate"] F --> B B -->|"Yes"| G["Return Solution"] ``` > [!note] 教学提示 > 贪心法的核心性质：**贪心选择性质**（局部最优导致全局最优）和**最优子结构**。并非所有问题都适用贪心法，如0-1背包问题用贪心法得不到最优解。 #### 4. 回溯法基本思想 回溯法的基本思想是什么？ **参考答案：** 1. **解空间**：定义问题的解空间树（子集树或排列树） 2. **深度优先搜索**：从根节点出发，按DFS策略搜索解空间 3. **剪枝函数**：用约束函数和限界函数剪去不可能产生最优解的子树 4. **回溯**：当搜索到某节点不满足约束时，回退到上一个节点，尝试其他分支 ```mermaid flowchart TD A["Root Node"] --> B["Expand Node"] B --> C{"Constraint Satisfied?"} C -->|"Yes"| D{"Leaf Node?"} D -->|"Yes"| E["Record Solution"] D -->|"No"| F["Go Deeper"] F --> B C -->|"No"| G["Prune & Backtrack"] G --> H{"More Branches?"} H -->|"Yes"| B H -->|"No"| I["Return to Parent"] ``` #### 5. 候诊椅问题 在某医院的大厅，100个座位的候诊椅排成一排。第一个来的人选择任意一个座位坐下；后来的人要么坐在空位上，要么坐在已坐有人的旁边。当两边都有人时，这个人要坐在这两人的中间。求第100个人最多可以坐几次空位。 **参考答案：** 这是一个经典的递推/概率问题。 分析表明，第100个人最多可以坐到 **1个空位**。 #### 6. 贪心、分治、动态规划比较 请简要描述贪心算法、分治法、动态规划法的基本思想及异同。 **参考答案：** | 特性 | 贪心法 | 分治法 | 动态规划 | |------|--------|--------|----------| | 核心思想 | 局部最优→全局最优 | 分解→递归→合并 | 子问题重叠→表格存储 | | 子问题 | 不回溯 | 独立不重叠 | 重叠子问题 | | 适用条件 | 贪心选择性质 | 可分解可合并 | 最优子结构+重叠子问题 | ```mermaid flowchart LR subgraph Greedy["Greedy"] G1["Local Optimal"] --> G2["Global Optimal"] end subgraph Divide["Divide & Conquer"] D1["Divide"] --> D2["Recurse"] D2 --> D3["Merge"] end subgraph DP["Dynamic Programming"] P1["Subproblems"] --> P2["Table Lookup"] P2 --> P3["Optimal Solution"] end ``` --- ### 三、代码分析题（每题8分，共3题，24分） **要求：300字以内。** #### 1. n皇后问题代码分析 阅读以下 n 后问题的分析代码，指出其算法策略： ```c int COL[20], MAIN_DIAG[40], COUNTER_DIAG[40]; int n, COUNT; int check(int t) { int i, j; i = t; j = COL[t]; while (i > 0) { if (COL[i] == j || (COL[i]-j)==i-t || (j-COL[i])==i-t) return 0; i--; } return 1; } void backtrack(int t) { int i; if (t > n) { for (i = 1; i <= n; i++) printf("%d ", COL[i]); printf("\n"); COUNT++; } else { for (i = 1; i <= n; i++) { COL[t] = i; if (check(t)) backtrack(t + 1); COL[t] = 0; } } } ``` **参考答案：** **算法策略：回溯法（深度优先搜索 + 剪枝）** - `COL[i]` 记录第 i 行皇后所在的列号 - `check(t)` 检查第 t 行放置皇后是否与前面已放置的皇后冲突（同行、同列、同对角线） - `backtrack(t)` 递归地在第 t 行尝试放置皇后，若 t > n 则找到一个解 - **时间复杂度**：O(n!) > [!note] 教学提示 > n皇后问题是回溯法的经典应用。剪枝函数 check() 是关键——它利用"同一列"和"同对角线"约束大幅减少搜索空间。对角线判断公式：`|COL[i]-COL[j]| == |i-j|`。 #### 2. 最大连续子数组和 阅读以下代码，判断代码实现了哪个算法分析设计原理： ```c int MaxSum(int a[], int n) { int sum = 0, b = 0; for (int i = 0; i < n; i++) { if (b > 0) b += a[i]; else b = a[i]; if (b > sum) sum = b; } return sum; } ``` **参考答案：** **算法策略：动态规划（Kadane算法）** - 维护当前子数组和 b，若 b > 0 则继续累加，否则从当前元素重新开始 - 状态转移：`b[i] = max(a[i], b[i-1] + a[i])` - **时间复杂度**：O(n)，**空间复杂度**：O(1) > [!tip] 关键理解 > 这是动态规划的经典应用。核心思想：如果前面的子数组和为负数，那么它对后面的结果只会产生负面影响，不如重新开始。这也是"局部最优→全局最优"的体现。 #### 3. max2函数分析 已知 max 函数，求 4 个数 a、b、c、d 中分别相邻两数的最大数，以 max 函数为基本对象，讨论 max2 函数的求解过程，写出 max2 的函数原型（C语言格式），并分析 max2 函数的时间复杂度和空间复杂度。 **参考答案：** ```c void max2(int a, int b, int c, int d, int *max1, int *max2, int *min1, int *min2); ``` 求解过程： 1. 比较 a 和 b → max1=max(a,b), min1=min(a,b) 2. 比较 c 和 d → max2=max(c,d), min2=min(c,d) 3. 从 {max1, max2} 中选较大者为总最大值 - **时间复杂度**：O(1)（最多3次比较） - **空间复杂度**：O(1) --- ### 四、算法设计与编程题（每题13分，共2题，26分） #### 1. 分治法求最大两个数和最小两个数 利用分治算法求一组数据中最大的两个数和最小的两个数。 **参考答案：** **算法策略：分治法** — 将数组分为两半，递归地在每半中找最大/最小的两个数，然后合并。 ```c // 分治法求最大两个数和最小两个数 void findMaxMin(int a[], int l, int r, int *max1, int *max2, int *min1, int *min2) { if (l == r) { *max1 = *min1 = a[l]; *max2 = INT_MIN; *min2 = INT_MAX; return; } if (r - l == 1) { // 基本情况：两个元素 if (a[l] > a[r]) { *max1 = a[l]; *max2 = a[r]; *min1 = a[r]; *min2 = a[l]; } else { *max1 = a[r]; *max2 = a[l]; *min1 = a[l]; *min2 = a[r]; } return; } // 分治：递归处理左右两半 int mid = (l + r) / 2; int lm1, lm2, rm1, rm2, ln1, ln2, rn1, rn2; findMaxMin(a, l, mid, &lm1, &lm2, &ln1, &ln2); findMaxMin(a, mid+1, r, &rm1, &rm2, &rn1, &rn2); // 合并：从4个候选中选最大2个和最小2个 // ...（合并逻辑） } ``` **时间复杂度**：T(n) = 2T(n/2) + O(1) = **O(n)** ```mermaid flowchart TD A["Array: a[l..r]"] --> B{"r-l <= 1?"} B -->|"Yes"| C["Direct Compare"] B -->|"No"| D["Divide: mid = (l+r)/2"] D --> E["findMaxMin(l, mid)"] D --> F["findMaxMin(mid+1, r)"] E --> G["Merge: Select Top 2 Max & Min"] F --> G ``` > [!note] 教学提示 > 分治法的关键是**分解**、**递归求解**、**合并**三步。本题的合并步骤需要从4个候选值中选出最大的两个和最小的两个，最多需要6次比较。 #### 2. 方阵最大路径和（动态规划） 在一个 n×n 的方阵中，填入 1, 2, 3... n² 个数字。方阵最下方有一人，此人走完 n 个方格后必须在最下方出来。任意时刻，每个人走过一方格，必须走到此方格的8个方向之一继续走。输入为 n，找出使所有数相加之和为最大的路径。 **参考答案：** **算法策略：动态规划** — 从最后一行向上递推，每个格子的最大路径和 = 自身值 + 下方三格中的最大值。 ```c int maxPathSum(int n, int grid[n][n]) { int dp[n][n]; for (int j = 0; j < n; j++) dp[n-1][j] = grid[n-1][j]; // 初始化最后一行 for (int i = n-2; i >= 0; i--) { for (int j = 0; j < n; j++) { dp[i][j] = grid[i][j]; int maxDown = dp[i+1][j]; // 正下方 if (j > 0 && dp[i+1][j-1] > maxDown) maxDown = dp[i+1][j-1]; // 左下方 if (j < n-1 && dp[i+1][j+1] > maxDown) maxDown = dp[i+1][j+1]; // 右下方 dp[i][j] += maxDown; } } int result = dp[0][0]; for (int j = 1; j < n; j++) if (dp[0][0+j] > result) result = dp[0][j]; return result; } ``` **时间复杂度**：O(n²)，**空间复杂度**：O(n²) ```mermaid flowchart TD A["Grid n x n"] --> B["Initialize Bottom Row"] B --> C["For i = n-2 downto 0"] C --> D["dp[i][j] = grid[i][j] + max(down-left, down, down-right)"] D --> E["Answer = max(dp[0][0..n-1])"] ``` > [!tip] 关键理解 > 动态规划的**状态定义**：`dp[i][j]` 表示从第 i 行第 j 列出发到最下方的最大路径和。**状态转移方程**：`dp[i][j] = grid[i][j] + max(dp[i+1][j-1], dp[i+1][j], dp[i+1][j+1])`。这是典型的"自底向上"递推。 --- ## 关联笔记 - [[算法设计与分析/试题册/试题2]] - [[算法设计与分析/试题册/试题3]] - [[算法设计与分析/试题册/试题4]] - [[算法设计与分析/试题册/试题5]]