final-exam/算法设计与分析/试题册/试题5.md

tags, create time

tags	create time
算法设计与分析 试题 武汉科技大学	2026-06-10 10:00

试题 5 — 武汉科技大学《算法设计与分析》

概述

• 课程：算法设计与分析
• 学校：武汉科技大学
• 题型：单项选择题、判断题、简答题、程序填空题、算法设计与编程题
• 知识点：递归复杂度、排序算法、图搜索(BFS/DFS)、动态规划、回溯法、四色问题

[!tip] 学习建议 本试题与试题4内容高度相似，建议对比学习。重点关注 程序填空题 中的递归框架，以及 四色地图着色 和 流水作业调度 两道编程题。

正文

一、单项选择题（每题2分，共15题，30分）

从备选的答案中选出合适的答案，并把答案标号写在答题纸中。

1. 下列哪些不是算法的 3 要素（ ）。

   • A. 操作
   • B. 控制结构
   • C. 数据结构
   • D. 输入输出

2. 冒泡排序的时间复杂度为（ ）。

   • A. O(n)
   • B. O(n²)
   • C. O(n³)
   • D. O(nlogn)

3. 下列算法中错误的是（ ）。

   • A. 算法的每一步骤必须有确切的含义
   • B. 算法的时间复杂度与实现语言无关
   • C. 对于特殊的输入，算法的时间复杂度可以是不固定的
   • D. 算法的运行时间与编写程序的语言无关

4. 求 n 个数中的最小数，时间复杂度为（ ）。

   • A. O(1)
   • B. O(n)
   • C. O(n²)
   • D. O(nlogn)

5. 调用函数 int fib(int n) { return (n>1 ? fib(n-1)+fib(n-2) : n); } 时间复杂度是（ ）。

   • A. O(n)
   • B. O(n²)
   • C. O(2ⁿ)
   • D. 无递归调用

6. 栈是一种基于什么机制实现的数据结构？（ ）

   • A. 先进先出
   • B. 先进后出
   • C. 随机存取
   • D. 索引存取

7. 流程图中表示判断的符号是（ ）。

   • A. 圆形
   • B. 椭圆形
   • C. 菱形
   • D. 平行四边形

8. 深度优先遍历在搜索空间树上的搜索方式为（ ）。

   • A. 广度优先
   • B. 深度优先
   • C. 最小耗费优先
   • D. 综合优先

9. 下述算法中正确的是（ ）。

   • A. 广度优先遍历算法只适合于无向图
   • B. 广度优先遍历算法只适合于有向图
   • C. 遍历一个无向图可能需要多次调用DFS或BFS
   • D. 只需一次调用DFS或BFS即可遍历一个无向图

10. 以下关于迭代法的描述中，正确的是（ ）。

    • A. 迭代算法在逻辑上总是可以转换为与它等价的递归算法
    • B. 每个递归算法在逻辑上总是可以转换为与它等价的循环结构算法
    • C. 迭代算法的可靠性比递归算法好
    • D. 迭代算法的执行效率一定比递归算法好

11. （ ）阶段是优化决策解决问题的过程。

    • A. 贪心算法
    • B. 动态规划
    • C. 分支限界
    • D. 迭代算法

12. 在算法的广度优先搜索策略中，一般采用的数据结构是（ ）。

13. 联欢晚会报数问题，凡是报3的人出列，编号为（ ）可以胜出。

    • A. 27
    • B. 33
    • C. 48
    • D. 144

14. 人工智能（AI）的英文全称是（ ）。

    • A. Automatic Intelligence
    • B. Automatic Information
    • C. Artificial Intelligence
    • D. Artificial Information

参考答案：

题号	1	2	3	4	5	6	7	8	9	10	11	12	13	14
答案	D	B	C	B	C	B	C	B	C	A	B	B	A	C

[!warning] 易错点 第1题：算法三要素是操作、控制结构、数据结构。第5题：斐波那契递归时间复杂度 O(2ⁿ)。第9题：无向图若有多个连通分量，需要多次调用BFS/DFS。

---

二、判断题（每题2分，共10题，20分）

正确的在括号内填 √，错误的填 ×。

1. 算法中的状态和步骤具有有穷性。（ ）
2. 一个算法应该适用于解决某类问题。（ ）
3. O(n²) 和 O(3n²+3) 的两个算法的时间复杂度相同。（ ）
4. 经验空间复杂度是指算法在执行过程中临时占用存储空间的大小。（ ）
5. 回溯法就是穷举法，所不同的是对一般问题回溯法比穷举法效率低。（ ）
6. 一个算法一般适用于一个特定类型的问题。（ ）
7. 动态规划适合求解具有重叠子问题性质的问题。（ ）
8. 贪心算法和动态规划法都用于求解最优问题，且在每一步只做一次决策。（ ）

参考答案：

题号	1	2	3	4	5	6	7	8
答案	×	√	√	×	×	√	√	×

---

三、简答题（每题10分，共2题，20分）

1. 台阶问题

如果楼板上有 s 阶台阶，每次可以上一步1阶，也可以上一步2阶，设计算法计算共有多少种上法？要求写出递推公式。

参考答案：

设 f(n) 为上 n 阶台阶的方法数：

• f(1) = 1，f(2) = 2
• f(n) = f(n-1) + f(n-2)，n ≥ 3

[!tip] 关键理解 最后一步要么上1阶（有 f(n-1) 种方法），要么上2阶（有 f(n-2) 种方法），两者相加即为总方法数。这就是斐波那契数列的变体！

2. 动态规划的基本思想步骤

参考答案：

1. 分析最优子结构：将原问题分解为若干子问题
2. 定义状态：确定状态变量
3. 建立状态转移方程：确定状态之间的递推关系
4. 计算顺序：自底向上递推或记忆化搜索
5. 构造最优解：回溯构造最优方案

[!important] 关键性质 动态规划适用于具有最优子结构和重叠子问题性质的问题。与分治法的区别：动态规划的子问题相互依赖，需要存储中间结果。

---

四、程序填空题（每空2分，2×10=20分）

1. 素数判定

try(int i) {
    if (i <= 20) {
        if (check1(i) && check2(i))
            output(i);       // (1) 输出结果
        else
            try(i+1);
    }
}
check1(int x) {
    for (int j = 2; j <= x-1; j++)
        if (x % j == 0) return 0;  // (2) 判断是否为素数
    return 1;
}
check2(int x) {
    for (int j = 2; j <= (x-1)/2; j++)
        if (x % j == 0) return 0;  // (3) 进一步筛选
    return 1;
}

(1) i <= 20　　(2) x % j == 0　　(3) 0

2. 迷宫搜索

search(int i, int j) {
    for (int di = -1; di <= 1; di++)
        for (int dj = -1; dj <= 1; dj++) {
            if (maze[i+di][j+dj] == 1) {  // (4) 可通行
                maze[i+di][j+dj] = 2;     // 标记已访问
                search(i+di, j+dj);
            }
        }
    maze[i][j] = 0;  // (5) 回溯
}

check(int i, int j) {
    if (i < 0 || i >= n || j < 0 || j >= m)
        flag = 0;
    else if (maze[i][j] == 0)
        flag = 0;
    else
        flag = 1;  // (6) 可通行
    return flag;
}

(4) 1　　(5) 0　　(6) 1

[!note] 教学提示 迷宫搜索中，maze[i][j] 的含义：0=未访问/障碍，1=可通行，2=已访问。回溯时将状态恢复为0。

---

五、算法设计与编程题（每题15分，共2题，30分）

1. 四色地图着色（回溯法）

图1是一个正在构造的四色地图，使用至多四种不同颜色对地图进行涂色，相同区域相邻颜色不同。

参考答案：

int data[6][6] = {0};  // 邻接矩阵
int color[6] = {0};

void tryColor(int s) {
    if (s > 6) { output(); return; }
    for (int i = 1; i <= 4; i++) {
        color[s] = i;
        if (colorSame(s) == 0) tryColor(s + 1);
        color[s] = 0;
    }
}

int colorSame(int s) {
    int flag = 0;
    for (int i = 1; i <= s-1; i++)
        if (data[i][s]==1 && color[i]==color[s]) flag = 1;
    return flag;
}

时间复杂度：O(4ⁿ)

flowchart TD
    A["Try Region s"] --> B["For color = 1 to 4"]
    B --> C{"Adjacent Same Color?"}
    C -->|"No"| D["Try Next Region (s+1)"]
    D --> E{"All Regions Colored?"}
    E -->|"Yes"| F["Output Solution"]
    E -->|"No"| B
    C -->|"Yes"| G["Backtrack: Try Next Color"]

2. 两台机器流水作业调度（Johnson算法）

某厂有6个加工任务，在印刷车间和装订车间所需时间如下：

任务	J1	J2	J3	J4	J5	J6
印刷	3	12	5	2	9	11
装订	8	10	9	6	3	1

参考答案：

Johnson算法：最优顺序 J4→J1→J3→J2→J5→J6，最短加工时间 43天

int job[6][2] = {{3,8},{12,10},{5,9},{2,6},{9,3},{11,1}};
int x[6], bestx[6], bestf = 32767;
int f1 = 0, f2[7] = {0};

void tryJob(int i) {
    if (i == 6) {
        for (int j = 0; j < 6; j++) bestx[j] = x[j];
        bestf = f2[i];
    } else {
        for (int j = i; j < 6; j++) {
            f1 += job[x[j]][0];
            f2[i] = (f2[i-1] > f1 ? f2[i-1] : f1) + job[x[j]][1];
            if (f2[i] < bestf) {
                swap(x[i], x[j]);
                tryJob(i + 1);
                swap(x[i], x[j]);  // 回溯
            }
            f1 -= job[x[j]][0];
        }
    }
}

[!tip] Johnson算法要点

1. 找矩阵中最小值
2. 若在机器1（上行）→ 排最前
3. 若在机器2（下行）→ 排最后
4. 划掉已排作业，重复直到排完

时间复杂度：O(nlogn)

---

关联笔记

• 算法设计与分析/试题册/试题1
• 算法设计与分析/试题册/试题2
• 算法设计与分析/试题册/试题3
• 算法设计与分析/试题册/试题4