算法设计与分析实验.docx
《算法设计与分析实验.docx》由会员分享，可在线阅读，更多相关《算法设计与分析实验.docx（9页珍藏版）》请在冰豆网上搜索。
算法设计与分析实验
实验一递归
1.1实验目的
1）掌握递归算法的概念，理解递归算法的思想
2）掌握递归函数的写法，熟练运用递归函数
3）正确分析递归算法的时空复杂度
1.2实验内容
1）编写程序递归地实现阶乘函数；
2）编写程序递归地实现Fibonacci数列；
3）编写程序递归实现整数划分问题
1.3实验步骤
1）写出阶乘函数的定义公式
2）创建一个java程序，递归实现阶乘函数
publicstaticintfactorial（intn）
{
if（n==0）return1;
returnn*factorial（n-1）;
}
3）写出Fibonacci数列的定义公式
4）创建一个java程序，递归实现Fibonacci数列
publicstaticintfibonacci（intn）
{
if（n<=1）return1;
returnfibonacci（n-1）+fibonacci（n-2）;
}
5）分析并写出整数划分的递归公式
6）创建一个java程序，递归实现整数划分问题
publicstaticintq（intn,intm）
{
if（（n<1）||（m<1））return0;
if（（n==1）||（m==1））return1;
if（nif（n==m）returnq（n,m-1）+1;
returnq（n,m-1）+q（n-m,m）;
}
1.4实验报告
把实验内容
（1），
（2），（3）写到实验报告上。
实验二分治策略
2.1实验目的
1）掌握分治法的概念，理解分治法的思想
2）掌握二分搜索，快速排序等最基本二分法的应用
3）正确分析分治法的时空复杂度
2.2实验内容
1）编程实现在一给定数列中查找某个元素；
2）编程实现快速排序算法；
3）编程实现最接近点对的问题。
（选做）
2.3实验步骤
1）写出二分搜索算法的伪代码
2）创建一个java程序，编程实现二分搜索
publicstaticintbinarySearch（int[]a,intx,intn）
{
intleft=0;intright=n-1;
while（left<=right）
{
intmiddle=（left+right）/2;
if（x==a[middle]）returnmiddle;
if（x>a[middle]）left=middle+1;
elseright=middle-1;
}
return-1;
}
3）写出快速排序算法的伪代码
4）创建一个java程序，编程实现快速排序
privatestaticvoidqSort（intp,intr）
{
if（p{
intq=partition（p,r）;
qSort（p,q-1）;
qSort（q+1,r）;
}
}
privatestaticintpartition（intp,intr）
{
inti=p,j=r+1;
Comparablex=a[p];
while（true）
{
while（a[++i].compareTo（x）<0&&iwhile（a[--j].compareTo（x）>0）;
if（i>=j）break;
MyMath.swap（a,i,j）;
}
a[p]=a[j];
a[j]=x;
returnj;
}
2.4实验报告
把实验内容
（1），
（2）写到实验报告上。
实验三动态规划
（一）
3.1实验目的
1）掌握动态规划的概念，理解动态规划的思想
2）掌握递归和递推这两种实现动态规划的实现方法
3）正确分析动态规划的时空复杂度
3.2实验内容
1）编程实现矩阵连乘问题（对于给定的相继n个矩阵{A1,A2,…,An}，如何确定计算矩阵连乘积A1A2…An的计算次序，使得依此次序计算矩阵连乘积需要的数乘次数最少）；
2）编程实现最长公共子序列问题（给定两个序列X={x1,x2,…,xm}和Y={y1,y2,…yn},找出X和Y的最长公共子序列）；
3）编程实现3个序列的最长公共子序列问题。
（选做）
3.3实验步骤
1）找出矩阵连乘问题中的状态转移方程
设计算A[i:
j],1<=i<=j<=n,所需的最小数乘次数为m[i][j],则原问题的最优值为m[1][n].
动态转移方程：
2）创建一个java程序，编程实现矩阵连乘问题
publicstaticvoidmatrixChain（int[]p,int[][]m,int[][]s）
{
intn=p.length-1;
for（inti=1;i<=n;i++）m[i][i]=0;
for（intr=2;r<=n;r++）
for（inti=1;i{
intj=i+r-1;
m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j];
s[i][j]=i;
for（intk=i+1;k{
intt=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
if（t{
m[i][j]=t;
s[i][j]=k;
}
}
}
}
3）找出最长公共子序列问题中的状态转移方程
设c[i][j]为序列X和Y的最长公共子序列的长度。
动态转移方程：
4）创建一个java程序，编程实现最长公共子序列问题
publicstaticintlcsLength（char[]x,char[]y,int[][]b）
{
intm=x.length-1;
intn=y.length-1;
int[][]c=newint[m+1][n+1];
for（inti=1;i<=m;i++）c[i][0]=0;
for（inti=1;i<=n;i++）c[0][i]=0;
for（inti=1;i<=m;i++）
for（intj=1;j<=n;j++）
{
if（x[i]==y[j]）
{
c[i][j]=c[i-1][j-1]+1;
b[i][j]=1;
}
elseif（c[i-1][j]>=c[i][j-1]）
{
c[i][j]=c[i-1][j];
b[i][j]=2;
}
else
{
c[i][j]=c[i][j-1];
b[i][j]=3;
}
}
returnc[m][n];
}
3.4实验报告
把实验内容
（1），
（2）写到实验报告上。
实验四动态规划
（二）
4.1实验目的
1）掌握动态规划的概念，理解动态规划的思想
2）掌握递归和递推这两种实现动态规划的实现方法
3）正确分析动态规划的时空复杂度
4.2实验内容
4.3实验步骤
4.4实验报告
实验五贪心算法
（一）
5.1实验目的
1）掌握贪心算法的概念，理解贪心算法的思想
2）掌握贪心算法的应用范围，熟悉几种经典的贪心算法
3）正确分析贪心算法的时空复杂度
5.2实验内容
1）编程实现活动安排问题（有n个活动的集合E={1,2,…,n}，其中，每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。
每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi，且si如何安排这些活动，使得安排的活动场次最多）。
2）编程实现哈夫曼编码。
（选做）
5.3实验步骤
1）验证活动安排问题拥有最优子结构
2）选择贪心策略（按结束时间fi的非减序排列，每次选取时间结束最早的活动）
3）用数学归纳法证明贪心算法能否得到整体最优解
设E={1,2,…,n}为所给的活动集合，由于E中活动按结束时间的非减序排列，故活动1具有最早的完成时间。
首先证明活动安排问题有一个最优解以贪心选择开始，即该最优解中包含活动1。
设A
E是所给的活动安排问题的一个最优解，且A中活动也按结束时间非减序排列，A中的第一个活动是活动k。
若k=1，则A就是以贪心选择开始的最优解；若k>1，则设B=A-{k}∪{1}。
由于f1<=fk，且A中活动是相容的，故B中的活动也是相容的。
又由于B中活动个数与A中活动个数相同，且A是最优的，故B也是最优的。
也就是说B是以贪心选择活动1开始的最优活动安排。
由此可见，总存在以贪心选择开始的最优活动安排方案。
若A是原问题的最优解，则A’=A-{1}是活动安排问题E’={i∈E：
si>=f1}的最优解。
反证，假设如能找到E’的一个解B’，它包含比A’更多的活动，则将活动1加入B’中将产生E的一个解B，它包含比A更多的活动，这与A的最优性矛盾。
因此，每一步所做出的贪心选择都将问题简化为一个更小的与原问题具有相同形式的子问题。
4）创建一个java程序，编程实现活动安排问题
publicstaticintgreedySeletor（int[]s,int[]f,boolean[]a）
{
intn=s.length-1;
a[1]=true;
intj=1;
intcount=1;
for（inti=2;i<=n;i++）
{
if（s[i]>=f[j]）
{
a[i]=true;
j=i;
count++;
}
else
a[i]=false;
}
returncount;
}
5.4实验报告
把实验内容
（1）写到实验报告上。
实验六贪心算法
（二）
6.1实验目的
6.2实验内容
6.3实验步骤
6.4实验报告
实验七回溯法
（一）
7.1实验目的
7.2实验内容
7.3实验步骤
7.4实验报告
实验八回溯法
（二）
8.1实验目的
8.2实验内容
8.3实验步骤
8.4实验报告
升级会员 