文章目录
前言
《算法设计与分析》课程实验的目的是为了使学生在课堂学习的同时，通过一系列的实验，使学生加深理解和更好地掌握《算法设计与分析》课程教学大纲要求的内容。
主要仪器设备及耗材
1.安装了Windows 10操作系统的PC机1台
2.PC机系统上安装了Microsoft Visual Studio 2019开发环境
以下是本篇文章正文内容，下面案例可供参考
一、分治法的应用
问题描述
i. 中位数问题
问题描述
设X[ 0 : n - 1]和Y[ 0 : n – 1 ]为两个数组，每个数组中含有n个已排好序的数。找出X和Y的2n个数的中位数。
编程任务
利用分治策略试设计一个O (log n)时间的算法求出这2n个数的中位数。
数据输入
由文件input.txt提供输入数据。文件的第1行中有1个正整数n（n<=200），表示每个数组有n个数。接下来的两行分别是X，Y数组的元素。
结果输出
程序运行结束时，将计算出的中位数输出到文件output.txt中。
输入文件示例 输出文件示例
input.txt output.txt
3 14
5 15 18
3 14 21
实现提示
比较两个序列的中位数大小，如果两个数相等，则该数为整个2n个数据的中位数，否则通过比较，分别减少两个序列的查找范围，确定查找的起止位置，继续查找。
ii. Gray码问题
问题描述
Gray码是一个长度为2n的序列。序列中无相同的元素，每个元素都是长度为n位的串，相邻元素恰好只有一位不同。用分治策略设计一个算法对任意的n构造相应的Gray码。
编程任务
利用分治策略试设计一个算法对任意的n构造相应的Gray码。
数据输入
由文件input.txt提供输入数据n。
结果输出
程序运行结束时，将得到的所有编码输出到文件output.txt中。
输入文件示例 输出文件示例
input.txt
3
output.txt
0 0 0
0 0 1
0 1 1
0 1 0
1 1 0
1 1 1
1 0 1
1 0 0
实现提示
把原问题分解为两个子问题，分别对两个子问题的每个数组后一位加0和1。
设计思想
分治策略
（1） 了解用分治法求解的问题：当要求解一个输入规模为n，且n的取值相当大的问题时，如果问题可以分成k个不同子集合，得到k个不同的可独立求解的子问题，其中1<k≤n，而且子问题与原问题性质相同，原问题的解可由这些子问题的解合并得出。那末，对于这类问题分治法是十分有效的。
（2） 掌握分治法的一般控制流程。
DanC(p,q)
global n，A[1:n]; integer m,p,q; // 1<=p<=q<=n
if Small(p,q) then return G(p,q);
else m=Divide(p,q); // p<=m<q
return Combine(DanC(p,m),DanC(m+1,q));
endif
end DanC
（3） 实现典型的分治算法的编程与上机实验，验证算法的时间复杂性函数。
伪代码描述(中位数问题)
输入：由文件input.txt提供输入数据。文件的第1行中有1个正整数n（n<=200），表示每个数组有n个数。接下来的两行分别是X，Y数组的元素。
输出：将计算出的中位数输出到文件output.txt中。
1.如果数组x,y都只有一个元素，则中位数等于这两个数的平均数
2.如果数组x,y有两个元素，因为数组元素按升序排序，则比较较小数组的最后一个数和较大数组的最后一个数来判断中位数等于哪两个数的平均数
3.当数组元素数较大时，则通过减小查询范围，查找的起止位置，继续查找。如果是偶数，则除以2，如果是奇数，则除以2加1。如果得到的两个位置的数相等，则该数为整个2n个数据的中位数，如果小于，则从x数组后一位开始，继续调用该函数；大于同理。
时间性能分析（中位数问题）
由于每次都是将数组分成两部分寻找中位数，从n,n/2,n/4,n/8……一直到1，所以时间复杂度为O(log2n).
源码（中位数问题）
#include<iostream>
#include<fstream>
using namespace std;
int zhongweishu(int *a, int *b,int n) {
if (n==1) return (*a+*b)/2;//x,y数组只有一个元素
else if (n == 2) {
if (*a >= *b) {
if(*(b+1)>*(a+1))return (*a + *(a + 1)) / 2;
else return (*a + *(b + 1)) / 2;
}
else {
if (*(a + 1) > * (b + 1))return (*(b + 1) + *b) / 2;
else return (*b + *(a + 1)) / 2;
}
}
int m;
if (n % 2 == 0)m = n / 2;
else m = n / 2 + 1;
if (*(a+m -1) == *(b + m - 1))
return *(a + m - 1);
else if (*(a + m - 1) < *(b + m - 1))
return zhongweishu(a+m-1, b, m);
else if (*(a + m - 1) > *(b + m - 1))
return zhongweishu(a, b + m - 1, m);
}
int main() {
//读取文件
ifstream in("input.txt");
ofstream out("output.txt");
if (!in)cout << "文件读取失败" << endl;
int n;//数组的大小
in>>n;//读取
int x[200], y[200];
for (int i = 0; i < n; i++) in >> x[i];
for (int i = 0; i < n; i++) in >> y[i];//依次读取到x和y数组
int* a = x;
int* b = y;
out << zhongweishu(a, b, n);
in.close();
out.close();
}
二、动态规划算法（1）
问题描述
i. 最大K乘积问题
问题描述
设I是一个n位十进制整数。如果将I划分为k段，则可得到k个整数。这k个整数的乘积称为I的一个k乘积。试设计一个算法，对于给定的I和k，求出I的最大k乘积。
例如十进制整数 1234 划分为 3 段可有如下情形：
1 × 2 × 34 = 68
1 × 23 × 4 = 92
12 × 3 × 4 = 144
编程任务
对于给定的I 和k，编程计算I 的最大k 乘积。
数据输入
输入的第1 行中有2个正整数n和k。正整数n是序列的长度；正整数k是分割的段数。接下来的一行中是一个n位十进制整数。（n<=10）
结果输出
计算出的最大k乘积。
输入文件示例 输出文件示例
input.txt output.txt
3 2
312 62
实现提示
参考矩阵连乘问题。
设计思想
（1） 理解最优子结构的问题。
有一类问题的活动过程可以分成若干个阶段，而且在任一阶段后的行为依赖于该阶段的状态，与该阶段之前的过程如何达到这种状态的方式无关。这类问题的解决是多阶段的决策过程。在50年代，贝尔曼（Richard Bellman）等人提出了解决这类问题的“最优化原理”，从而创建了最优化问题的一种新的算法设计方法－动态规划。
对于一个多阶段过程问题，是否可以分段实现最优决策，依赖于该问题是否有最优子结构性质，能否采用动态规划的方法，还要看该问题的子问题是否具有重叠性质。
最优子结构性质：原问题的最优解包含了其子问题的最优解。
子问题重叠性质：每次产生的子问题并不总是新问题，有些子问题被反复计算多次。问题的最优子结构性质和子问题重叠性质是采用动态规划算法的两个基本要素。
（2） 理解分段决策Bellman方程。
每一点最优都是上一点最优加上这段长度。即当前最优只与上一步有关。
us=0
uj=min{ui+wij}.(i不等于j)
us 初始值，uj第j段的最优值。
（3） 一般方法
1） 找出最优解的性质，并刻画其结构特征；
2） 递归地定义最优值（写出动态规划方程）；
3） 以自底向上的方式计算出最优值；
4） 根据计算最优值时得到的信息，构造一个最优解。
步骤1-3是动态规划算法的基本步骤。在只需要求出最优值的情形，步骤4可以省略，步骤3中记录的信息也较少；若需要求出问题的一个最优解，则必须执行步骤4，步骤3中记录的信息必须足够多以便构造最优解。
伪代码描述
输入：输入的第1 行中有2个正整数n和k。正整数n是序列的长度；正整数k是分割的段数。接下来的一行中是一个n位十进制整数。（n<=10）
输出：计算出的最大k乘积。
1.初始子问题：无论多少位整数，被划分为一段，其最大k乘积均为其本身。
2. 下一阶段子问题：前i位整数被划分为j段所得到的最大乘积等于在（前a位这个数分为j-1段所得最大乘积与第a+1位到第i位组成的(j-i+1)位整数的乘积）之间的最大值
a的取值范围为（1<=a<=i-1）
3.然后进行比较，选择最大的结果
列表
q\p 1 2 3 4
1 1 12 123 1234
2 0 2 36 492
3 0 0 6 144
4 0 0 0 24
时间性能分析
第一个for循环的时间性能是O（n）,第二个循环是两层嵌套的for循环，内层循环里还有一个循环，其时间性能是O（k*n2），所以，算法的时间复杂性为O（k*n2）.
源码
#include<iostream>
#include<fstream>
using namespace std;
void getnumber(int number[20], int num, int n)
{
int b = 0;
for (int a = n - 1; a >= 0; a--)
{
b = num % 10;
num = num / 10;
number[a] = b;
}
return;
}
//求第p到q位整数所代表的数值
int countnumber(int p, int q, int* number)
{
int newnumber = 0;
for (int i = p; i <= q; i++)
{
newnumber = newnumber * 10 + number[i];
}
return newnumber;
}
int main()
{
//文件中输入的第一行为n 和 k ， 第二行为I
int k, n, I;
int number[20];
int product[20][20];
//读取文件
ifstream in("input.txt");
ofstream out("output.txt");
in >> n;
in >> k;
in >> I;
//用数组存储文件中读取的数
getnumber(number, I, n);
if (k == 1)//当分段数为1时，最大乘积数为本身(初始子问题)
out << I << "\n";
for (int i = 0; i < n; i++) product[0][i] = countnumber(0, i, number);
for (int i = 0; i < n; i++)//i表列
{
for (int j = 1; j < k; j++)//j表行
{
if (j > i)//若划分段数大于整数位数，则结果为0
{
product[j][i] = 0;
break;
}
else
{
int max = 0; int temp = 0;
for (int a = i - 1; a >= 0; a--)
{
int num = countnumber(a + 1, i, number);
temp = num * product[j - 1][a];
if (temp > max) max = temp;
}
product[j][i] = max;
}
}
}
out << product[k - 1][n - 1] << "\n";
in.close();
out.close();
return 0;
}
动态规划算法（2）
问题描述
ii. 游艇租用问题
问题描述
长江游艇俱乐部在长江上设置了n个游艇出租站1，2，…，n。游客可在这些游艇出租站租用游艇，并在下游的任何一个游艇出租站归还游艇。游艇出租站i到游艇出租站j之间的租金为r(i,j),1i<jn。试设计一个算法，计算出从游艇出租站1到游艇出租站n所需的最少租金。
编程任务
对于给定的游艇出租站i到游艇出租站j之间的租金为r(i,j),1i<jn，编程计算从游艇出租站1到游艇出租站n所需的最少租金。
数据输入
由文件input.txt提供输入数据。文件的第1行中有1个正整数n（n<=200），表示有n个游艇出租站。接下来的n-1行是r(i,j),1<=i<j<=n。
(例如：
3
5 15
7
表示一共有3个出租站点，其中
第1个站点到第2个的租金为5
第1个站点到第3个的租金为15
第2个站点到第3个的租金为7
)
结果输出
程序运行结束时，将计算出的从游艇出租站1到游艇出租站n所需的最少租金输出到文件output.txt中。
输入文件示例 输出文件示例
input.txt output.txt
3 12
5 15
7
input.txt output.txt
4 15
3 7 19
5 13
8
设计思想
（1） 理解最优子结构的问题。
有一类问题的活动过程可以分成若干个阶段，而且在任一阶段后的行为依赖于该阶段的状态，与该阶段之前的过程如何达到这种状态的方式无关。这类问题的解决是多阶段的决策过程。在50年代，贝尔曼（Richard Bellman）等人提出了解决这类问题的“最优化原理”，从而创建了最优化问题的一种新的算法设计方法－动态规划。
对于一个多阶段过程问题，是否可以分段实现最优决策，依赖于该问题是否有最优子结构性质，能否采用动态规划的方法，还要看该问题的子问题是否具有重叠性质。
最优子结构性质：原问题的最优解包含了其子问题的最优解。
子问题重叠性质：每次产生的子问题并不总是新问题，有些子问题被反复计算多次。问题的最优子结构性质和子问题重叠性质是采用动态规划算法的两个基本要素。
（2） 理解分段决策Bellman方程。
每一点最优都是上一点最优加上这段长度。即当前最优只与上一步有关。
us=0
uj=min{ui+wij}.(i不等于j)
us 初始值，uj第j段的最优值。
（3） 一般方法
1） 找出最优解的性质，并刻画其结构特征；
2） 递归地定义最优值（写出动态规划方程）；
3） 以自底向上的方式计算出最优值；
4） 根据计算最优值时得到的信息，构造一个最优解。
步骤1-3是动态规划算法的基本步骤。在只需要求出最优值的情形，步骤4可以省略，步骤3中记录的信息也较少；若需要求出问题的一个最优解，则必须执行步骤4，步骤3中记录的信息必须足够多以便构造最优解。
伪代码描述
输入:文件的第1行中有1个正整数n（n<=200），表示有n个游艇出租站。接下来的n-1行是r(i,j),1<=i<j<=n。
输出：程序运行结束时，计算出从游艇出租站1到游艇出租站n所需的最少租金。
划分子问题：初始子问题：第一个站点到第一个站点的租金为0；确定动态方程：从第一个站点到第i个站点所需最少租金=直接从第1个站点到第i个站点的租金和第一个站点到第k个站点所需最少租金加上直接从第k个站点到第i个站点的租金之间的最小值；最后综上，求解出最少租金。
时间性能分析
输入读取文件数据时所使用的循环是一个两层嵌套循环，其时间性能是O（n2）,进行动态转移时，i从2到n-1,j从i-1到1，其时间效能也是O（n2），所以算法的时间复杂度是O（n^2）。
源码
#include<iostream>
#include<fstream>
using namespace std;
int main()
{
int n;
int r[200][200];//fare[i][j]表示从第i+1个站点到第j+1个站点的费用
int cost[200];//cost[i]表示从第1个站点到第i+1个站点所需要的最小费用
ifstream in("input.txt");
ofstream out("output.txt");
in >> n;
for (int i = 0; i < n; i++)
{
for (int j = i; j < n; j++)
{
if (i == j) r[i][j] = 0;//同一个点
else in >> r[i][j];//输入费用
}
}
cost[0] = 0;//同一个点
if (n >1 ) cost[1] = r[0][1];
if(n>2) {
int temp = 0;
//从第一个点到第i+1个点的最小费用等于第1个站点到第i+1个点的费用
for (int i = 2; i < n; i++) cost[i] = r[0][i];
for (int i = 2; i < n; i++)
{
for (int j = i - 1; j > 0; j--)
{
//动态转移
temp = cost[j] + r[j][i];
if (temp < cost[i]) cost[i] = temp;
}
}
}
out << cost[n - 1] << "\n";
in.close();
out.close();
return 0;
}
总结
详情可参考以下链接：
链接：冲冲冲~
提取码：5k5f
复制这段内容后打开百度网盘手机App，操作更方便哦