算法设计与分析实验报告.docx

算法设计与分析实验报告.docx

《算法设计与分析实验报告.docx》由会员分享，可在线阅读，更多相关《算法设计与分析实验报告.docx（44页珍藏版）》请在冰豆网上搜索。

算法设计与分析实验报告

算法设计与分析实验报告

实验一分治法…………………………………………………………………………2

1.1实验要求………………………………………………………………………2

1.2实验内容………………………………………………………………………2

1.3核心算法………………………………………………………………………2

1.4程序代码………………………………………………………………………4

1.5实验结果………………………………………………………………………8

实验二贪心法………………………………………………………………………10

2.1实验要求……………………………………………………………………10

2.2实验内容……………………………………………………………………10

2.3核心算法……………………………………………………………………10

2.4程序代码……………………………………………………………………12

2.5实验结果……………………………………………………………………18

实验三动态规划…………………………………………………………………20

3.1实验要求……………………………………………………………………20

3.2实验内容……………………………………………………………………20

3.3核心算法……………………………………………………………………20

3.4程序代码……………………………………………………………………21

3.5实验结果……………………………………………………………………24

实验四深度优先搜索……………………………………………………………26

4.1实验要求……………………………………………………………………26

4.2实验内容……………………………………………………………………26

4.3核心算法……………………………………………………………………26

4.4程序代码……………………………………………………………………27

4.5实验结果……………………………………………………………………28

实验五回溯法………………………………………………………………………30

5.1实验要求……………………………………………………………………30

5.2实验内容……………………………………………………………………30

5.3核心算法……………………………………………………………………30

5.4程序代码……………………………………………………………………31

5.5实验结果……………………………………………………………………33

实验一分治法

一.实验要求

1.了解用分治法求解的问题：

当要求解一个输入规模为n，且n的取值相当大的问题时，

如果问题可以分成k个不同子集合，得到k个不同的可独立求解的子问题，其中1

那末，对于这类问题分治法是十分有效的。

2.掌握分治法的一般控制流程。

DanC（p,q）

globaln，A[1:

n];integerm,p,q;//1pqn

ifSmall（p,q）thenreturnG（p,q）;

elsem=Divide（p,q）;//pm

returnCombine（DanC（p,m）,DanC（m+1,q））;

endif

endDanC

3．实现典型的分治算法的编程与上机实验，验证算法的时间复杂性函数。

二.实验内容

1.编程实现归并排序算法和快速排序算法，程序中加入比较次数的计数功能，输出排序结果和比较次数。

2.输入10组相同的数据，验证排序结果和完成排序的比较次数。

3.与复杂性函数所计算的比较次数比较。

4.用表格列出比较结果。

5.给出文字分析。

三.程序算法

1.归并排序算法

procedureMERGESORT（low，high）

//A（low；high）是一个全程数组，它含

有high-low+1≥0个待排序的元素//

integerlow，high；

iflow

thenmid←，//求这个集合的分割点//

callMERGESORT（low，mid）//将一个子集合排序//

callMERGESORT（mid+1，high）//将另一个子集合排序

callMERGE（low，mid，high）//归并两个已排序的子集合//

endif

endMERGESORT

归并两个已排序的集合

procedureMERGE（low，mid，high）

//A（low：

high）是一个全程数组//

//辅助数组B（low；high）//

integerh，i，j，k；

h←low；i←low；j←mid+1；

whileh≤midandj≤highdo//当两个集合都没取尽时//

ifA（h）≤A（j）thenB（i）←A（h）；h←h+1

elseB（i）←A（j）；j←j+1

endif

i←i+1

repeat

ifh>midthen

fork←jtohighdo//处理剩余的元素//

B（i）←A（k）；i←i+1

repeat

elsefork←htomiddo

B（i）←A（k）；i←i+1

repeat

endif

将已归并的集合复制到A

endMERGE

2.快速排序算法

QuickSort（p,q）

//将数组A[1:

n]中的元素

A[p],A[p+1],,A[q]按不降次序排列，

并假定A[n+1]是一个确定的、且大于

A[1:

n]中所有的数。

//

intp,q;globaln,A[1:

n];

ifp

j=Partition（p,q+1）;//划分后j成为划分元素的位置

QuickSort（p,j-1）;

QuickSort（j+1,q）;

endif

endQuickSort

procedurePARTITION（m，p）

//退出过程时，p带着划分元素所在的下标位置。

//

integerm，p，i；globalA（m：

p-1）

v←A（m）；i←m//A（m）是划分元素//

loop

loopi←i+1untilA（i）≥vrepeat//i由左向右移//

loopp←p-1untilA（p）≤vrepeat//p由右向左移//

ifi

thencallINTERCHANGE（A（i），A（p））//A（i）和A（p）换位//

elseexit

endif

repeat

A（m）←A（p）；A（p）←v//划分元素在位置p//

EndPARTITION

四.程序代码

1.归并排序

#include

#include

#include

#include

#defineM11

typedefintKeyType;

typedefintElemType;

structrec{

KeyTypekey;

ElemTypedata;

};

typedefrecsqlist[M];

classguibing{

public:

guibing（sqlistb）

{

for（inti=0;i

r[i]=b[i];

}

voidoutput（sqlistr,intn）

{

for（inti=0;i

cout<

cout<

}

voidxuanze（sqlistb,intm,intn）

{

inti,j,k;

for（i=m;i

{

k=i;

for（j=i;j

if（b[k].key>b[j].key）k=j;

if（k!

=i）

{

rectemp=b[k];

b[k]=b[i];

b[i]=temp;

}

}

}

voidmerge（intl,intm,inth,sqlistr2）

{

xuanze（r,l,m）;

xuanze（r,m,h）;

output（r,M）;

inti,j,k;

k=i=l;

for（j=m;i

{

if（r[i].key<=r[j].key）

{

r2[k]=r[i];

i++;

}

else

{

r2[k]=r[j];

j++;

}

output（r2,M）;

}

while（j

{

r2[k]=r[j];

j++;

k++;

}

while（i<=m）

{

r2[k]=r[i];

i++;

k++;

}

output（r2,M）;

}

private:

sqlistr;

};

voidmain（）

{

cout<<"guibingfa1运行结果:

\n";

sqlista,b;

inti,j=0,k=M/2,n=M;

srand（time（0））;

for（i=0;i

{

a[i].key=rand（）%80;b[i].key=0;

}

guibinggx（a）;

cout<<"排序前数组:

\n";

gx.output（a,M）;

cout<<"数组排序过程演示:

\n";

gx.merge（j,k,n,b）;

cout<<"排序后数组:

\n";

gx.output（b,M）;

cin.get（）;

}

2.快速排序

#include

#include

#include

#include

#defineMAXI10

typedefintKeyType;

typedefintElemType;

structrec{

KeyTypekey;

ElemTypedata;

};

typedefrecsqlist[MAXI];

classkuaisu

{

public:

kuaisu（sqlista,intm）:

n（m）

{

for（inti=0;i

}

voidquicksort（ints,intt）

{

inti;

if（s

i=part（s,t）;

quicksort（s,i-1）;

quicksort（i+1,t）;

}

elsereturn;

}

intpart（ints,intt）

{

inti,j;

recp;

i=s;j=t;p=b[s];

while（i

{

while（i=p.key）j--;

b[i]=b[j];

while（i

b[j]=b[i];

}

b[i]=p;

output（）;

returni;

}

voidoutput（）

{

for（inti=0;i

cout<

cout<

}

private:

sqlistb;

intn;

};

voidmain（）

{

cout<<"kuaisu1.cpp运行结果:

\n";

sqlista1;

inti,n=MAXI,low=0,high=9;

srand（time（0））;

for（i=0;i

a1[i].key=rand（）%80;

kuaisupx（a1,n）;

cout<<"数组排序过程演示:

\n";

px.quicksort（low,high）;

cout<<"排序后数组:

\n";

px.output（）;

cin.get（）;

}

五.实验结果

1.归并排序

2.快速排序

实验二贪心法

一.实验要求

1.优化问题

有n个输入，而它的解就由这n个输入满足某些事先给定的约束条件的某个子集组

成，而把满足约束条件的子集称为该问题的可行解。

可行解一般来说是不唯一的。

那些使目标函数取极值（极大或极小）的可行解，称为最优解。

2.贪心法求优化问题

算法思想：

在贪心算法中采用逐步构造最优解的方法。

在每个阶段，都作出一个看上去最优的决策（在一定的标准下）。

决策一旦作出，就不可再更改。

作出贪心决策的依据称为贪心准则（greedycriterion）。

3.一般方法

1）根据题意，选取一种量度标准。

2）按这种量度标准对这n个输入排序

3）依次选择输入量加入部分解中。

如果当前这个输入量的加入，不满足约束条件，则不把此输入加到这部分解中。

procedureGREEDY（A，n）/*贪心法一般控制流程*/

//A（1：

n）包含n个输入//

solutions←φ//将解向量solution初始化为空／

fori←1tondo

x←SELECT（A）

ifFEASIBLE（solution，x）

thensolutions←UNION（solution，x）

endif

repeat

return（solution）

endGREEDY

4.实现典型的贪心算法的编程与上机实验，验证算法的时间复杂性函数。

二.实验内容

1.编程实现背包问题贪心算法和最小生成树prim算法。

通过具体算法理解如何通过局部最优实现全局最优，并验证算法的时间复杂性。

2.输入5个的图的邻接矩阵，程序加入统计prim算法访问图的节点数和边数的语句。

3.将统计数与复杂性函数所计算的比较次数比较，用表格列出比较结果，给出文字分析。

三.程序算法

1.背包问题的贪心算法

procedureKNAPSACK（P，W，M，X，n）

//P（1：

n）和W（1；n）分别含有按

P（i）/W（i）≥P（i+1）/W（i+1）排序的n件物品的效益值

和重量。

M是背包的容量大小，而x（1：

n）是解向量

realP（1：

n），W（1：

n），X（1：

n），M，cu；

integeri，n；

X←0//将解向量初始化为零

cu←M//cu是背包剩余容量

fori←1tondo

ifW（i）>cuthenexitendif

X（i）←1

cu←cu-W（i）

repeat

ifi≤nthenX（i）←cu/W（i）

endif

endGREEDY-KNAPSACK

procedureprim（G,）

status←“unseen”//T为空

status[1]←“treenode”//将1放入T

foreachedge（1,w）do

status[w]←“fringe”//找到T的邻接点

dad[w]←1;//w通过1与T建立联系

dist[w]←weight（1,w）//w到T的距离

repeat

whilestatus[t]≠“treenode”do

pickafringeuwithmindist[w]//选取到T最近的节点

status[u]←“treenode”

foreachedge（u,w）do

修改w和T的关系

repeat

repeat

2.Prim算法

PrimMST（G，T，r）{

 //求图G的以r为根的MST，结果放在T=（U，TE）中

   InitCandidateSet（…）；//初始化：

设置初始的轻边候选集，并置T=（{r}，￠）

   for（k=0；k

       （u，v）=SelectLiShtEdge（…）；//选取轻边（u，v）；

        T←T∪{（u，v）}；//扩充T，即（u，v）涂红加入TE，蓝点v并人红点集U

       ModifyCandidateSet（…）；//根据新红点v调整候选轻边集

     } 

  }

四.程序代码

1.背包问题贪心算法

#include

structgoodinfo

{

floatp;//物品效益

floatw;//物品重量

floatX;//物品该放的数量

intflag;//物品编号

};//物品信息结构体

voidInsertionsort（goodinfogoods[],intn）

{

intj,i;

for（j=2;j<=n;j++）

{

goods[0]=goods[j];

i=j-1;

while（goods[0].p>goods[i].p）

{

goods[i+1]=goods[i];

i--;

}

goods[i+1]=goods[0];

}

}//按物品效益，重量比值做升序排列

voidbag（goodinfogoods[],floatM,intn）

{

floatcu;

inti,j;

for（i=1;i<=n;i++）

goods[i].X=0;

cu=M;//背包剩余容量

for（i=1;i

{

if（goods[i].w>cu）//当该物品重量大与剩余容量跳出

break;

goods[i].X=1;

cu=cu-goods[i].w;//确定背包新的剩余容量

}

if（i<=n）

goods[i].X=cu/goods[i].w;//该物品所要放的量

for（j=2;j<=n;j++）

{

goods[0]=goods[j];

i=j-1;

while（goods[0].flag

{

goods[i+1]=goods[i];

i--;

}

goods[i+1]=goods[0];

}

cout<<"最优解为:

"<

for（i=1;i<=n;i++）

{

cout<<"第"<

";

cout<

}

}

voidmain（）

{

cout<<"|--------运用贪心法解背包问题---------|"<

cout<<"|-------------------------------------|"<

intj;

intn;

floatM;

goodinfo*goods;//定义一个指针

while（j）

{

cout<<"请输入物品的总数量：

";

cin>>n;

goods=newstructgoodinfo[n+1];//

cout<<"请输入背包的最大容量：

";

cin>>M;

cout<

inti;

for（i=1;i<=n;i++）

{goods[i].flag=i;

cout<<"请输入第"<

";

cin>>goods[i].w;

cout<<"请输入第"<

";

cin>>goods[i].p;

goods[i].p=goods[i].p/goods[i].w;//得出物品的效益，重量比

cout<

}

Insertionsort（goods,n）;

bag（goods,M,n）;

cout<<"press<1>torunagian"<

cout<<"press<0>toexit"<

cin>>j;

}

}

2.Prim算法

#include

#include

#include

#defineINFINITYINT_MAX

#defineMAX_VERTEX_NUM20

typedefintVRType;

typedefintInfoType;

typedefcharVerTexType;

typedefstructArcCell

{

VRTypeadj;

InfoType*info;

}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedefstruct

{

VerTexTypevexs[MAX_VERTEX_NUM];

AdjMatrixarcs;

intvexnum,arcnum;

}MGraph;

typedefstruct

{

VerTexTypeadjvex;

VRTypelowcost;

}closedge[MAX_VERTEX_NUM];

voidCreateGraph（MGraph&G）;

voidMiniSpanTree_PRIM（MGraphG,VerTexTypeu）;

intLocateVex（MGraphG,VerTexTypeu）;

intminimum（closedgeclose）;

voidmain（void）

{

inti,j;

MGraphG;

CreateGraph（G）;

for（i=0;i

{

for（j=0;j

{

cout<