《算法设计与分析》实验指导.docx
《《算法设计与分析》实验指导.docx》由会员分享，可在线阅读，更多相关《《算法设计与分析》实验指导.docx（32页珍藏版）》请在冰豆网上搜索。
《算法设计与分析》实验指导
《算法分析与设计》实验指导.
实验一锦标赛问题
[实验目的]
1.基本掌握分治算法的原理.
2.掌握递归算法及递归程序的设计.
3.能用程序设计语言求解锦标赛等问题的算法.
[预习要求]
1.认真阅读数据结构教材和算法设计教材,了解分治算法原理;
2.设计用分治算法求解背包问题的数据结构与程序代码.
[实验题]
【问题描述】设有n=2k个运动员要进行网球循环赛。
现要设计一个满足以下要求的比赛日程表：
（1）每个选手必须与其他n-1个选手各赛一次；
（2）每个选手一天只能参赛一次；
（3）循环赛在n-1天内结束。
请按此要求将比赛日程表设计成有n行和n-1列的一个表。
在表中的第i行，第j列处填入第i个选手在第j天所遇到的选手。
其中1≤i≤n，1≤j≤n-1。
[实验提示]
我们可以按分治策略将所有的选手分为两半，则n个选手的比赛日程表可以通过n/2个选手的比赛日程表来决定。
递归地用这种一分为二的策略对选手进行划分，直到只剩下两个选手时，比赛日程表的制定就变得很简单。
这时只要让这两个选手进行比赛就可以了。
1
2
3
4
5
6
7
1
2
3
4
5
6
7
8
2
1
4
3
6
7
8
5
3
4
1
2
7
8
5
6
1
2
3
4
3
2
1
8
5
6
7
1
2
3
4
5
6
7
8
1
4
3
2
1
2
1
4
3
6
5
8
7
2
1
4
3
1
2
3
4
1
2
7
8
5
6
3
2
1
4
2
1
4
3
2
1
8
7
6
5
4
3
2
1
（1）
（2）（3）
图12个、4个和8个选手的比赛日程表
图1所列出的正方形表（3）是8个选手的比赛日程表。
其中左上角与左下角的两小块分别为选手1至选手4和选手5至选手8前3天的比赛日程。
据此，将左上角小块中的所有数字按其相对位置抄到右下角，又将左下角小块中的所有数字按其相对位置抄到右上角，这样我们就分别安排好了选手1至选手4和选手5至选手8在后4天的比赛日程。
依此思想容易将这个比赛日程表推广到具有任意多个选手的情形。
[实验步骤]
1.采用递归方式设计并实现算法并准备测试用例,修改并调试程序,直至正确为止;
2.应用设计的算法和程序求锦标赛问题;
3.去掉测试程序,将你的程序整理成功能模块存盘备用.
[实验报告要求]
1.阐述实验目的和实验内容;
2.阐述分治算法原理;
3.提交实验程序的功能模块;
4.记录最终测试数据和测试结果。
[思考与练习]
【金块问题】老板有一袋金块（共n块，n是2的幂（n>=2）），将有两名最优秀的雇员每人得到其中的一块，排名第一的得到最重的那块，排名第二的雇员得到袋子中最轻的金块。
假设有一台比较重量的仪器，请用最少的比较次数找出最重和最轻的金块。
实验二背包问题
[实验目的]
4.能用程序设计语言实现求解背包问题的算法;
5.基本掌握动态规划法（贪心）的原理方法.
[预习要求]
3.认真阅读数据结构教材和算法设计教材,了解背包问题的常用算法原理;
4.设计用动态规划算法求解背包问题的数据结构和递归程序.
[实验题]
【背包问题】有不同价值、不同重量的物品n件，求从这n件物品中选取一部分物品的选择方案，使选中物品的总重量不超过指定的限制重量W，但选中物品的价值之和最大。
[实验提示]
设n件物品的重量分别为w0、w1、…、wn-1，物品的价值分别为v0、v1、…、vn-1。
采用递归寻找物品的选择方案。
设前面已有了多种选择的方案，并保留了其中总价值最大的方案于数组option[]，该方案的总价值存于变量maxv。
当前正在考察新方案，其物品选择情况保存于数组cop[]。
假定当前方案已考虑了前i-1件物品，现在要考虑第i件物品；当前方案已包含的物品的重量之和为tw；至此，若其余物品都选择是可能的话，本方案能达到的总价值的期望值为tv。
算法引入tv是当一旦当前方案的总价值的期望值也小于前面方案的总价值maxv时，继续考察当前方案变成无意义的工作，应终止当前方案，立即去考察下一个方案。
因为当方案的总价值不比maxv大时，该方案不会被再考察，这同时保证函数后找到的方案一定会比前面的方案更好。
对于第i件物品的选择考虑有两种可能：
（1）考虑物品i被选择，这种可能性仅当包含它不会超过方案总重量限制时才是可行的。
选中后，继续递归去考虑其余物品的选择。
（2）考虑物品i不被选择，这种可能性仅当不包含物品i也有可能会找到价值更大的方案的情况。
按以上思想写出递归算法如下：
try（物品i，当前选择已达到的重量和，本方案可能达到的总价值tv）
{/*考虑物品i包含在当前方案中的可能性*/
if（包含物品i是可以接受的）
{将物品i包含在当前方案中；
if（itry（i+1,tw+物品i的重量,tv）;
else
/*又一个完整方案，因为它比前面的方案好，以它作为最佳方案*/
以当前方案作为临时最佳方案保存;
恢复物品i不包含状态；
}
/*考虑物品i不包含在当前方案中的可能性*/
if（不包含物品i仅是可男考虑的）
if（itry（i+1,tw,tv-物品i的价值）；
else
/*又一个完整方案，因它比前面的方案好，以它作为最佳方案*/
以当前方案作为临时最佳方案保存;
}
为了理解上述算法，特举以下实例。
设有4件物品，它们的重量和价值见表：
物品
0
1
2
3
重量
5
3
2
1
价值
4
4
3
1
并设限制重量为7。
则按以上算法，下图表示找解过程。
由图知，一旦找到一个解，算法就进一步找更好的佳。
如能判定某个查找分支不会找到更好的解，算法不会在该分支继续查找，而是立即终止该分支，并去考察下一个分支。
[实验步骤]
4.设计并实现算法并准备测试用例,修改并调试程序,直至正确为止;
5.应用设计的算法和程序求解背包问题;
6.去掉测试程序,将你的程序整理成功能模块存盘备用.
[实验报告要求]
5.阐述实验目的和实验内容;
6.阐述求解背包问题的算法原理;
7.提交实验程序的功能模块;
8.记录最终测试数据和测试结果。
[思考与练习]
请用其它的算法（如贪心、分支限界等）求解背包问题。
实验三作业调度问题
[实验目的]
1.熟悉多机调度问题的算法；
2.进一步掌握贪心算法
3.提高分析与解决问题的能力。
[预习要求]
1.认真阅读教材或参考书,掌握贪心算法的基本思想；
2.写出求解“作业调度”的程序；
3.设计好测试用例。
[实验题]
要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。
约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。
作业不能拆分成更小的子作业。
[实验提示]
1.把作业按加工所用的时间从大到小排序；
2.如果作业数目比机器的数目少或相等，则直接把作业分配下去；
3 .如果作业数目比机器的数目多，则每台机器上先分配一个作业，如下的作业分配时，是选那个表头上s最小的链表加入新作业。
typedefstructJob
{
intID;//作业号
inttime;//作业所花费的时间
}Job;
typedefstructJobNode//作业链表的节点
{
intID;
inttime;
JobNode*next;
}JobNode,*pJobNode;
typedefstructHeader //链表的表头
{
ints;
pJobNodenext;
}Header,pHeader;
intSelectMin（Header*M,intm）
{
intk=0;
for（inti=1;i {
if（M[i].s }
returnk;
}
[实验步骤]
1先用贪心算法求解该问题，并测试你的程序，直至正确为止；
2针对问题实例，实录运行时的输入、输出文件；
3将你的程序和实录的界面存盘备用。
[实验报告要求]
阐述实验目的和实验内容；
1提交模块化的实验程序源代码；
2简述程序的测试过程，提交实录的输入、输出文件；
3鼓励对实验内容展开讨论，鼓励提交思考与练习题的代码和测试结果。
实验四回溯算法设计
[实验目的]
1.掌握回溯法解题的基本思想；
2.掌握回溯算法的设计方法；
3.针对子集和数问题，熟练掌握回溯递归算法、迭代算法的设计与实现。
[预习要求]
1.认真阅读教材或参考书,掌握回溯法解题的基本思想,算法的抽象控制策略；
2.了解子集和数问题及解向量的定长和变长状态空间表示；
3.针对解向量的定长表示,设计状态空间树节点扩展的规范（限界）函数及实现方法；
4.分析深度优先扩展状态空间树节点或回溯的条件；
5.分析和设计生成解向量各分量可选值的实现方法；
6.设计和编制回溯算法的递归和迭代程序。
[实验题]#include
#defineMAXN100
inta[MAXN];
voidcomb（intm,intk）
{inti,j;
for（i=m;i>=k;i--）
{a[k]=i;
if（k>1）
comb（i-1,k-1）;
else
{for（j=a[0];j>0;j--）
printf（“%4d”,a[j]）;
printf（“/n”）;
}
}
}
voidmain（）
{a[0]=3;
comb（5,3）;
}
【组合数】找出从自然数1，2，…，n中任取r个数的所有组合。
#defineMAXN100
inta[MAXN];
voidcomb（intm,intr）
{inti,j;
i=0;
a[i]=1;
do{
if（a[i]-i<=m-r+1
{if（i==r-1）
{for（j=0;jprintf（“%4d”，a[j]）；
printf（“\n”）；
}
a[i]++;
continue;
}
else
{if（i==0）
return;
a[--i]++;
}
}while
（1）
}
main（）
{comb（5,3）；
}
[实验提示]
回溯法也称为试探法，该方法首先暂时放弃关于问题规模大小的限制，并将问题的候选解按某种顺序逐一枚举和检验。
当发现当前候选解不可能是解时，就选择下一个候选解；倘若当前候选解除了还不满足问题规模要求外，满足所有其他要求时，继续扩大当前候选解的规模，并继续试探。
如果当前候选解满足包括问题规模在内的所有要求时，该候选解就是问题的一个解。
在回溯法中，放弃当前候选解，寻找下一个候选解的过程称为回溯。
扩大当前候选解的规模，以继续试探的过程称为向前试探。
可以采用回溯法找问题的解，将找到的组合以从小到大顺序存于a[0]，a[1]，…，a[r-1]中，组合的元素满足以下性质：
（1） a[i+1]>a[i]，后一个数字比前一个大；
（2） a[i]-i<=n-r+1。
按回溯法的思想，找解过程可以叙述如下：
首先放弃组合数个数为r的条件，候选组合从只有一个数字1开始。
因该候选解满足除问题规模之外的全部条件，扩大其规模，并使其满足上述条件
（1），候选组合改为1，2。
继续这一过程，得到候选组合1，2，3。
该候选解满足包括问题规模在内的全部条件，因而是一个解。
在该解的基础上，选下一个候选解，因a[2]上的3调整为4，以及以后调整为5都满足问题的全部要求，得到解1，2，4和1，2，5。
由于对5不能再作调整，就要从a[2]回溯到a[1]，这时，a[1]=2，可以调整为3，并向前试探，得到解1，3，4。
重复上述向前试探和向后回溯，直至要从a[0]再回溯时，说明已经找完问题的全部解。
按上述思想写成程序如下：
voidcomb（intn,intr）
{inti,j;i=0;a[i]=1;
do{if（a[i]-i<=n-r+1）/*还可以向前试探*/
{if（i==r-1）/*已找到一个组合*/
{for（j=0;ja[i]++;continue;}
i++;a[i]=a[i-1]+1;/*向前试探*/
}else{if（i==0）return;/*已找到所有解*/
a[--i]++;}/*回溯*/
}while
（1）;
}
[实验步骤]
1.录入、修改并测试你的程序，直至正确为止；
2.针对问题实例，实录运行时的输入、输出界面；
3.将你的程序和实录的界面存盘备用。
[实验报告要求]
1.阐述实验目的和实验内容；
2.提交模块化的实验程序源代码；
3.简述程序的测试过程，提交实录的输入、输出界面；
4.鼓励对实验内容展开讨论，鼓励提交思考与练习题的代码和测试结果。
[思考与练习]
1．在3×3个方格的方阵中要填入数字1到N（N≥10）内的某9个数字，每个方格填一个整数，似的所有相邻两个方格内的两个整数之和为质数。
试求出所有满足这个要求的各种数字填法。
#include
#defineN12
voidwrite（inta[]）
{inti,j;
for（i=0;i<3;i++）
{for（j=0;j<3;j++）
printf（“%3d”，a[3*i+j]）；
printf（“\n”）；
}
scanf（“%*c”）；
}
intb[N+1];
inta[10];
intisprime（intm）
{inti;
intprimes[]={2,3,5,7,11,17,19,23,29,-1};
if（m==1||m%2=0）return0;
for（i=0;primes[i]>0;i++）
if（m==primes[i]）return1;
for（i=3;i*i<=m;）
{if（m%i==0）return0;
i+=2;
}
return1;
}
intcheckmatrix[][3]={{-1},{0,-1},{1,-1},{0,-1},{1,3,-1},
{2,4,-1},{3,-1},{4,6,-1},{5,7,-1}};
intselectnum（intstart）
{intj;
for（j=start;j<=N;j++）
if（b[j]）returnj
return0;
}
intcheck（intpos）
{inti,j;
if（pos<0）return0;
for（i=0;（j=checkmatrix[pos][i]）>=0;i++）
if（！
isprime（a[pos]+a[j]）
return0;
return1;
}
intextend（intpos）
{a[++pos]=selectnum
（1）；
b[a][pos]]=0;
returnpos;
}
intchange（intpos）
{intj;
while（pos>=0&&（j=selectnum（a[pos]+1））==0）
b[a[pos--]]=1;
if（pos<0）return–1
b[a[pos]]=1;
a[pos]=j;
b[j]=0;
returnpos;
}
voidfind（）
{intok=0,pos=0;
a[pos]=1;
b[a[pos]]=0;
do{
if（ok）
if（pos==8）
{write（a）；
pos=change（pos）；
}
elsepos=extend（pos）；
elsepos=change（pos）；
ok=check（pos）；
}while（pos>=0）
}
voidmain（）
{inti;
for（i=1;i<=N;i++）
b[i]=1;
find（）；
}
2．试针对0/1背包问题设计回溯算法，比较与子集和数问题的算法差异。
3．求出在一个n×n的棋盘上，放置n个不能互相捕捉的国际象棋“皇后”的所有布局。
这是来源于国际象棋的一个问题。
皇后可以沿着纵横和两条斜线4个方向相互捕捉。
如图所示，一个皇后放在棋盘的第4行第3列位置上，则棋盘上凡打“×”的位置上的皇后就能与这个皇后相互捕捉。
12345678
××
×××
×××
××Q×××××
×××
×××
××
××
从图中可以得到以下启示：
一个合适的解应是在每列、每行上只有一个皇后，且一条斜线上也只有一个皇后。
求解过程从空配置开始。
在第1列至第m列为合理配置的基础上，再配置第m+1列，直至第n列配置也是合理时，就找到了一个解。
接着改变第n列配置，希望获得下一个解。
另外，在任一列上，可能有n种配置。
开始时配置在第1行，以后改变时，顺次选择第2行、第3行、…、直到第n行。
当第n行配置也找不到一个合理的配置时，就要回溯，去改变前一列的配置。
得到求解皇后问题的算法如下：
{输入棋盘大小值n；
m=0;
good=1;
do{
if（good）
if（m==n）
{输出解；
改变之，形成下一个候选解；
}
else扩展当前候选接至下一列；
else改变之，形成下一个候选解；
good=检查当前候选解的合理性；
}while（m!
=0）；
}
在编写程序之前，先确定边式棋盘的数据结构。
比较直观的方法是采用一个二维数组，但仔细观察就会发现，这种表示方法给调整候选解及检查其合理性带来困难。
更好的方法乃是尽可能直接表示那些常用的信息。
对于本题来说，“常用信息”并不是皇后的具体位置，而是“一个皇后是否已经在某行和某条斜线合理地安置好了”。
因在某一列上恰好放一个皇后，引入一个一维数组（col[]），值col[i]表示在棋盘第i列、col[i]行有一个皇后。
例如：
col[3]=4，就表示在棋盘的第3列、第4行上有一个皇后。
另外，为了使程序在找完了全部解后回溯到最初位置，设定col[0]的初值为0当回溯到第0列时，说明程序已求得全部解，结束程序运行。
为使程序在检查皇后配置的合理性方面简易方便，引入以下三个工作数组：
（1）数组a[]，a[k]表示第k行上还没有皇后；
（2）数组b[]，b[k]表示第k列右高左低斜线上没有皇后；
（3）数组c[]，c[k]表示第k列左高右低斜线上没有皇后；
棋盘中同一右高左低斜线上的方格，他们的行号与列号之和相同；同一左高右低斜线上的方格，他们的行号与列号之差均相同。
初始时，所有行和斜线上均没有皇后，从第1列的第1行配置第一个皇后开始，在第m列col[m]行放置了一个合理的皇后后，准备考察第m+1列时，在数组a[]、b[]和c[]中为第m列，col[m]行的位置设定有皇后标志；当从第m列回溯到第m-1列，并准备调整第m-1列的皇后配置时，清除在数组a[]、b[]和c[]中设置的关于第m-1列，col[m-1]行有皇后的标志。
一个皇后在m列，col[m]行方格内配置是合理的，由数组a[]、b[]和c[]对应位置的值都为1来确定。
细节见以下程序：
【程序】
#include
#include
#defineMAXN20
intn,m,good;
intcol[MAXN+1],a[MAXN+1],b[2*MAXN+1],c[2*MAXN+1];
voidmain（）
{intj;
charawn;
printf（“Entern:
“）；scanf（“%d”，&n）；
for（j=0;j<=n;j++）a[j]=1;
for（j=0;j<=2*n;j++）cb[j]=c[j]=1;
m=1;col[1]=1;good=1;col[0]=0;
do{
if（good）
if（m==n）
{printf（“列\t行”）；
for（j=1;j<=n;j++）
printf（“%3d\t%d\n”，j,col[j]）；
printf（“Enteracharacter（Q/qforexit）！
\n”）；
scanf（“%c”，&awn）；
if（awn==’Q’||awn==’q’）exit（0）；
while（col[m]==n）
{m--;
a[col[m]]=b[m+col[m]]=c[n+m-col[m]]=1;
}
col[m]++;
}
else
{a[col[m]]=b[m+col[m]]=c[n+m-col[m]]=0;
col[++m]=1;
}
else
{while（col[m]==n）
{m--;
a[col[m]]=b[m+col[m]]=c[n+m-col[m]]=1;
}
col[m]++;
}
good=a[col[m]]&&b[m+col[m]]&&c[n+m-col[m]];
}while（m!
=0）；
}
试探法找解算法也常常被编写成递归函数，下面两程序中的函数queen_all（）和函数queen_one（）能分别用来解皇后问题的全部解和一个解。
【程序】
#include
#include
#defineMAXN20
intn;
intcol[MAXN+1],a[MAXN+1],b[2*MAXN+1],c[2*MAXN+1];
voidmain（）
{intj;
pr
升级会员 