一、算法阅读分析题：
1.分析如下算法，回答问题（10分）。
- 该算法的作用是什么(2分)？
- 分析该算法的时间复杂度(5分)?
- 设计算法的一个输入，并给出对应的算法输出结果(3分)
（1）该算法的作用
这段代码实现了归并排序（Merge Sort）算法，用于对数组进行排序。归并排序是一种分治策略的排序方法，它将数组分成越来越小的部分排序，然后合并以产生最终的排序数组。
（2）分析该算法的时间复杂度
归并排序的时间复杂度为O(nlogn)，其中 n 是数组中元素的数量。具体分析如下：
分解：每次递归调用将问题分成两半，总共需要分 logn 层，因为每次都是对半分。
合并操作：每层合并的时间复杂度为O(n)，因为每个元素最多被复制和移动一次。
整体复杂度：由于有logn 层，每层都需要 O(n) 的时间，因此总的时间复杂度是 O(nlogn)。
（3）设计算法的一个输入，并给出对应的算法输出结果
假设我们有一个包含7个元素的数组，元素如下：5,2,9,1,5,6,7
输入流程：
用户输入元素的个数 n=7。
用户依次输入数组元素：5, 2, 9, 1, 5, 6, 7。
算法输出：
经过归并排序后，数组应该是排序好的状态。按照给定的输入，排序的结果如下：
1,2,5,5,6,7,9
合并排序结果：1 2 5 5 6 7 9
这个输出展示了经过归并排序处理的数组，从最小到最大顺序排列
2.分析n皇后问题的求解算法，回答如下问题（10分）
- 该算法是否随机算法，为什么(3分)？
- 如果是，属于哪一类随机算法，为什么(3分)?
- 变量num、count的作用是什么(2分)?
- 函数queen的作用是什么(2分)?
| 算法2 #include <stdio.h> #include <stdlib.h> #include <time.h> #define N 20 int q[N], num=0; void dispasolution(int n) { printf(" 第%d次运行找到一个解: ",num); for (int i=1;i<=n;i++) printf("(%d,%d) ",i,q[i]); printf("\n"); } int randa(int a,int b) //产生n个[a,b]的随机数 { return rand()%(b-a+1)+a; } bool place(int i,int j) { if (i==1) return true; int k=1; while (k<i) { if ((q[k]==j) || (abs(q[k]-j)==abs(i-k))) return false; k++; } return true; } | bool queen(int i,int n) { int count,j; if (i>n) { dispasolution(n); return true; } else { count=0; while (count<=n) { j=randa(1,n); count++; if (place(i,j)) break; } if (count>n) return false; q[i]=j; queen(i+1,n); } } void main() { int n=8; printf("%d皇后问题求解如下：\n",n); srand((unsigned)time(NULL)); while (num<20) { if (queen(1,n)) break; num++; printf(" 第%d次运行没有找到解\n",num); } } |
（1）该算法是否为随机算法，以及原因
是的，这是一个随机算法。因为算法中使用了随机数生成器来决定皇后的位置，即 j=randa(1,n); 表示在每次尝试放置皇后时，其列位置 j 是随机选择的。这意味着算法的行为和结果部分依赖于随机数生成，每次执行的流程可能不同。
（2）属于哪一类随机算法，以及原因
这个算法属于蒙特卡洛算法。蒙特卡洛算法通过随机抽样来解决问题，其特点是运行时间固定，但解的正确性具有概率性。在这里，通过随机选择皇后的列位置，尝试找到一个符合条件的解，如果达到一定的尝试次数（这里是 n 次）仍未找到有效的位置，则认为当前的递归分支失败。
（3）变量 num、count 的作用
num: 这个变量用来记录算法尝试找到解的次数。每次运行算法，num 递增，直到找到解或达到某个特定的运行次数限制。在这段代码中，num 也用来标记找到解的次数，输出是第几次找到了一个解。
count: 在 queen 函数中，count 用来记录在给定的行 i 上尝试放置皇后的次数。当 count 超过 n（棋盘的大小），如果还没有找到合适的位置，则当前的放置尝试失败。
（4）函数 queen 的作用
函数 queen 是解决 n 皇后问题的核心递归函数。它尝试在棋盘上的第 i 行放置一个皇后，并确保这个放置是安全的，即不会导致任何两个皇后互相攻击。如果在第 i 行成功放置了皇后，函数会递归调用自己，尝试在下一行放置另一个皇后。如果成功放置了所有皇后（达到棋盘的尽头），则通过调用 dispasolution 函数显示解决方案。如果在某一行无法成功放置皇后，函数返回 false，这通常会引发回溯到上一行，尝试不同的位置。
3.分析如下会议安排算法，回答问题（10分）
- 该算法的作用是什么(3分)？
- 该算法属于哪一类算法策略，求解策略具有什么特点(3分)?
- 语句if(meet[i].beg>=last)的作用是什么(2分)?
- 语句 last = meet[i].end的作用是什么(2分)?
| #include <iostream> #include <algorithm> #include <cstring> using namespace std; struct Meet { int beg; int end; int num; }meet[1000]; void init() { int s,e; cout <<"输入会议总数："<<endl; cin >> n; int i; cout <<"输入开始时间和结束时间:"<<endl; for(i=0;i<n;++i) { cin>>s>>e; meet[i].beg=s; meet[i].end=e; meet[i].num=i+1; } } bool cmp(Meet x,Meet y) { if (x.end == y.end) return x.beg > y.beg; return x.end < y.end; } | void solve() { sort(meet,meet+n,cmp); cout <<"排完序的会议时间如下:"<<endl; int i; cout <<"会议编号："<<" 开始时间 "<<" 结束时间"<<endl; ans=1; int last = meet[0].end; for( i = 1;i < n;++i) { if(meet[i].beg>=last) { ans++; last = meet[i].end; cout <<"选择第"<<meet[i].num<<"个会议"<<endl; } } cout <<"最多可以安排" <<ans << "个会议"<<endl; } int main() { init(); solve(); return 0; } |
（1）算法的作用
该算法的主要作用是解决会议室安排问题，即在给定一系列会议的开始时间和结束时间的情况下，选择尽可能多的会议进行安排，使得这些会议之间不发生时间上的冲突。
（2）算法类别与求解策略特点
这个算法属于贪心算法策略。其特点在于每一步都做出当前看起来最优的选择（这里是选择最早结束的会议），希望这样的局部最优选择能导致全局最优解。在会议安排问题中，按会议的结束时间对会议进行排序，并贪心地选择每个会议是实现总体目标的有效策略。
（3）语句 if(meet[i].beg>=last) 的作用
这个语句用于检查当前考虑的会议 meet[i] 的开始时间是否不早于上一个被选中的会议的结束时间 last。如果 meet[i].beg 大于或等于 last，这意味着当前会议可以在不与已选会议冲突的情况下被安排。这是贪心选择的关键条件，确保会议之间没有时间重叠。
（4）语句 last = meet[i].end 的作用
该语句更新变量 last 的值为当前被选中会议的结束时间。这样做的目的是记录下一个会议必须开始的最早时间，即不能早于当前会议的结束时间。这是为了保证后续选择的会议不会与前面已经选择的会议重叠，从而最大化可以安排的会议数量
二、解答题：（共40 分） | 评卷人 | 得分 |
4.假设用于通信的电文仅由8个字母{ a,b,c,d,e,f,g,h } 构成，它们在电文中出现的概率分别为{0.05,0.29,0.07,0.08,0.14,0.23,0.03,0.11}，设计一种编码方案，能够以最快的速度进行传输(10分)
（1）描述所用的求解算法，该算法属于何种算法策略（6分）
（2）给出8个字母的编码（4分）
（1）求解算法描述及其策略
所用的求解算法为 哈夫曼编码（Huffman Coding），这是一种基于贪心策略的编码方法。哈夫曼编码通过构建一棵优化的二叉树来最小化编码长度，使得总体传输速度最快。
算法策略：贪心算法。哈夫曼编码过程中，总是选择频率最低的两个节点组合成新的节点，这种局部最优选择可以导致全局最优的编码长度。
哈夫曼编码的基本步骤：
初始化：为电文中的每个字符创建一个节点，并将其作为独立的树，每棵树的“权重”是该字符在电文中的概率。
构建优先队列：将所有节点放入一个优先队列（或最小堆），按照概率排序。
构建哈夫曼树：
从优先队列中取出两个概率最小的节点，合并为一个新的节点，其概率是两个子节点概率的和。
将新节点重新插入优先队列。
重复上述过程，直到优先队列中只剩一个节点，这就是哈夫曼树的根节点。
生成编码：从根节点开始，向下遍历到每个叶节点（字符），左分支代表0，右分支代表1，路径上的序列即为该字符的哈夫曼编码。
（2）编码示例
以给定的字符概率，构建哈夫曼树并为每个字符生成编码。这里先假设执行了哈夫曼编码的标准过程，下面是可能的编码结果：
a : 1101
b : 0
c : 1111
d : 1110
e : 10
f : 01
g : 1100
h : 101
5. 使用分治算法，对n个关键字进行排序(10分)。
（1）描述你所采用的分治算法及其计算步骤（5分）；
（2）举例说明(n>6)，各趟排序结束时，关键字序列的状态（5分）。
（1）分治算法描述及计算步骤
对于排序问题，使用 归并排序（Merge Sort）是一种经典的分治算法。归并排序将大问题分解成小问题，处理后再合并结果，以达到整体上的有序。
基本步骤：
分解：将当前序列分成两个子序列，每个子序列大约有一半的长度。
递归排序：递归地对两个子序列进行归并排序，直到子序列长度为1或0，这时子序列已经有序。
合并：将两个有序的子序列合并成一个有序序列。
（2）举例说明
假设有8个关键字，初始序列为：[8, 3, 9, 6, 2, 7, 5, 4]
排序过程示例：
初始序列：[8, 3, 9, 6, 2, 7, 5, 4]
第一趟排序：
分解为两个子序列：[8, 3, 9, 6] 和 [2, 7, 5, 4]
分别对这两个子序列排序。
第二趟排序：
对[8, 3, 9, 6]分解排序后：[3, 8] 和 [6, 9]
对[2, 7, 5, 4]分解排序后：[2, 7] 和 [4, 5]
第三趟排序：
合并[3, 8]和[6, 9]得到[3, 6, 8, 9]
合并[2, 7]和[4, 5]得到[2, 4, 5, 7]
最终合并：
合并[3, 6, 8, 9]和[2, 4, 5, 7]得到最终有序序列[2, 3, 4, 5, 6, 7, 8, 9]
每趟结束时关键字序列状态：
初始分解：[8, 3, 9, 6], [2, 7, 5, 4]
第二趟后：[3, 8, 6, 9], [2, 7, 4, 5]
第三趟后：[3, 6, 8, 9], [2, 4, 5, 7]
最终合并：[2, 3, 4, 5, 6, 7, 8, 9]
6.0-1背包问题：给定n个物品，1个背包，背包容量为C，n个物品的重量和价值分别为：(wi,vi)i=1,2,3,...,n。物品不能分割，求解在不超过背包容量的前提下，怎么装能够使得装入的物品总价值最大(10分)。
- 分析并说明问题的特征，并根据问题特征选择合适的算法策略（2分）;
- 描述解决该问题的算法原理及求解思路(可使用使用文字或递推公式，5分)；
（3）举例并求出问题的解(n>4)（3分）。
（1）问题特征与算法策略选择
问题特征：
0-1背包问题中，每个物品只能被选取一次，不能分割。
背包有固定的容量限制。
目标是最大化背包中物品的总价值。
算法策略：选择动态规划来解决这个问题，因为它适合处理基于限制条件的最优化问题，尤其适用于背包问题的离散选择和容量限制。
（2）算法原理及求解思路
动态规划解法的基本思想：
定义dp[i][j]为考虑前i个物品，当背包容量为j时能够装入的最大价值。
状态转移方程：
其中，w_i和v_i分别是第i个物品的重量和价值。
如果不选取第i个物品，则最大价值由前i-1个物品决定，即dp[i-1][j]。
如果选取第i个物品（前提是j >= w_i），则价值是该物品的价值加上剩余容量下前i-1个物品的最大价值，即dp[i-1][j-w_i] + v_i。
初始化：
dp[0][j] = 0 对于所有j，因为没有物品时最大价值为0。
dp[i][0] = 0 对于所有i，因为容量为0时不能装任何物品。
（3）举例求解
假设有5个物品，背包的容量为10，每个物品的重量和价值如下：
物品1: 重量2，价值6
物品2: 重量5，价值9
物品3: 重量4，价值5
物品4: 重量2，价值4
物品5: 重量3，价值7
初始化动态规划表格：创建一个二维数组 dp 来存储中间结果，其中 dp[i][j] 表示考虑前 i 个物品，背包容量为 j 时的最大价值。
填充表格：通过比较不包括当前物品与包括当前物品的情况（如果重量允许），更新表格以得到最大价值。
返回最终结果：表格的最后一个元素 dp[n][capacity] 包含了在给定背包容量和物品列表下的最大价值。
7. 假设需要从A地到B地运送运送物品，途中具有e条路段，中间具有n个站点，站点i和站点j之间的运输量不能超过Cij，如何安排运输方案才能达到最大运输量，问答下列问题(10分)
（1）描述解决该问题的算法运行原理及求解思路(可使用使用文字或公式，6分)；
（2）搜索运输路径时，设计出两种不同的搜索方法，并将其描述出来(4分)。
（1）算法运行原理及求解思路
这个问题是典型的最大流问题，在图论中广泛研究。问题的核心是找到从源点（A地）到汇点（B地）的最大可能流量。解决这一问题的算法运行原理基于寻找增广路径（augmenting paths），即那些还有剩余容量可供流动的路径，并通过这些路径持续增加从源点到汇点的流量。
Ford-Fulkerson 方法是解决此类问题的一个常用策略。它使用以下步骤：
初始化流网络：每条边的初始流量设为0。
寻找增广路径：使用深度优先搜索（DFS）或广度优先搜索（BFS）找到从源点到汇点的一条路径，此路径上的每条边的剩余容量（原始容量减去已用流量）都大于0。
更新流量：对找到的增广路径上的每条边更新流量。增加的流量是该路径上可用的最小剩余容量。
重复过程：重复步骤2和3，直到无法找到新的增广路径为止。此时的流量即为最大流。
这种方法利用局部增广路径逐步推进，直到达到流网络的流量平衡。
（2）搜索运输路径的两种不同方法
方法一：广度优先搜索（BFS）- Edmonds-Karp 算法
原理：使用广度优先搜索来寻找增广路径，这种方法在每次迭代中都找到最短的增广路径，从而可以在多项式时间内解决最大流问题。
优点：防止了路径回环的问题，且在稠密图中表现良好。
方法二：深度优先搜索（DFS）- Ford-Fulkerson 方法
原理：使用深度优先搜索寻找增广路径。DFS更适合于发现任意可行的增广路径，尤其是在网络结构复杂或路径选择较多的情况下。
优点：实现简单，对于一些特定情况可能更快找到增广路径。
这两种方法各有优势，BFS的Edmonds-Karp算法保证了寻找最短的增广路径，通常效率更高、更稳定；而DFS的Ford-Fulkerson方法在实现上更灵活，对于小规模或结构特殊的图表现可能更优。选择哪种方法取决于具体问题的规模和图的特性。
三、算法设计题：（共 30 分） | 评卷人 | 得分 |
8.假设有n个机器零件{P1,P2,…,Pn}需要加工，每个机器零件必须先由机器A加工，然后才能由机器B进行加工；零件Pi在机器A的加工时间为{t11,t12,…,t1n}，零件Pi在机器B的加工时间为{t21,t22,…,t2n}，请设计算法，求出一种总花费时间最短的零件加工顺序。(15分)
- 写出二种能够解决该问题的算法策略，分析、比较其优缺点(5分)；
- 选择其中一种算法策略解决该问题，并描述所选算法策略的基本思想2)；
- 用代码、自然语言、流程图等设计所选算法(5分);
- 分析所选算法的时间复杂度(3分)。
1. 解决算法策略及其分析比较
策略一：贪心算法（最短加工时间优先）
优点：实现简单，计算速度快。
缺点：可能不会得到全局最优解，只能保证局部最优。
策略二：Johnson算法（两机器流水作业调度）
优点：可以在特定条件下（两机器情况）提供最优解。
缺点：只适用于两个机器的情况，扩展性有限。
2. 选定算法策略：Johnson算法
Johnson算法适用于两机器的流水线作业调度，其目标是最小化总完成时间。其基本思想是根据特定的排序规则来安排作业，这一规则确保了在两机器流水作业情况下的最优解。
3. 算法描述（自然语言）
基本步骤：
创建列表：将所有零件按机器A和机器B的加工时间列出。
排序规则：如果零件在机器A的加工时间少于在机器B的时间，则按机器A的时间升序排序；否则，按机器B的时间降序排序。
调度：根据上述排序结果，依次安排零件的加工顺序。
执行：按照这个顺序，先在机器A上加工完成后，再在机器B上加工。
4. 时间复杂度分析
Johnson算法主要的时间消耗在排序步骤，使用常规排序算法（如归并排序或快速排序）的时间复杂度为 O(nlogn)。因此，整体算法的时间复杂度为O(nlogn)。
这种方法通过有效的排序规则确保了每个零件都以最优的顺序进入机器，从而实现了总加工时间的最小化。
9.设A和B是2个字符串。要用最少的字符操作将字符串A转换为字符串B。这里所说的字符操作包括：删除一个字符；插入一个字符；将一个字符改为另一个字符(15分)。
- 给出求解问题的算法策略（2分）；
- 写出该算法策略的基本思想（4分）；
- 用代码、自然语言、流程图等描述出所设计的算法(9分)。
（1）算法策略
针对将字符串A转换为字符串B的最少字符操作问题，适用的算法策略是动态规划。
（2）算法策略的基本思想
动态规划算法通过构建一个二维表格，其中的每个单元格 dp[i][j] 表示将字符串A的前i个字符转换为字符串B的前j个字符所需的最小操作数。通过递推的方式填充这个表格，可以计算出从A到B的最小编辑距离。三种基本操作是：删除一个字符、插入一个字符、替换一个字符，每种操作的代价均为1。
（3）算法描述
初始化表格：首先，创建一个大小为 (m+1) x (n+1) 的二维数组 dp，其中 m 和 n 分别是字符串 A 和 B 的长度。dp[i][j] 表示将 A 的前 i 个字符转换成 B 的前 j 个字符所需的最少操作次数。
设置基本条件：初始化表格的第一行和第一列。dp[i][0] 表示将 A 的前 i 个字符全部删除以匹配空字符串 B，因此 dp[i][0] = i。同理，dp[0][j] 表示将空字符串 A 通过插入操作变为 B 的前 j 个字符，所以 dp[0][j] = j。
填充表格：对于表格中的每一个元素 dp[i][j]，计算将 A 的前 i 个字符转换为 B 的前 j 个字符的最小操作数。如果 A 的第 i 个字符与 B 的第 j 个字符相同（注意：由于索引从0开始，因此对应的字符是 A[i-1] 和 B[j-1]），则 dp[i][j] = dp[i-1][j-1]，表示不需要额外操作。如果字符不同，我们有三种操作可以选择：
删除操作：dp[i-1][j] + 1，即删除 A 的第 i 个字符，然后将 A 的前 i-1 个字符转换为 B 的前 j 个字符。
插入操作：dp[i][j-1] + 1，即在 A 的 i 个字符后插入一个新字符（与 B 的第 j 个字符相同），然后将 A 的前 i 个字符转换为 B 的前 j-1 个字符。
替换操作：dp[i-1][j-1] + 1，即将 A 的第 i 个字符替换为 B 的第 j 个字符，然后将 A 的前 i-1 个字符转换为 B 的前 j-1 个字符。
得到结果：表格的右下角元素 dp[m][n] 包含了将整个字符串 A 转换为整个字符串 B 所需的最小操作数。
