均不满足判断,所以0不存在
(二)、快速排序问题
1、编程语言不限,实现快速排序算法并对算法的复杂性进行分析。
#include
#defineN6
voidquicksort(inta[],intlow,inthigh)
{
inti,j,temp;
i=low;
j=high;
temp=a[low];
if(low>high)
return;
while(i!
=j)
{
while(a[j]>=temp&&j>i)
j--;
if(j>i)
a[i++]=a[j];
while(a[i]<=temp&&j>i)
i++;
if(j>i)
a[j--]=a[i];
}
a[i]=temp;
quicksort(a,low,i-1);
quicksort(a,i+1,high);
}
voidmain()
{
inta[N];
printf("请输入数组:
");
for(intk=0;k<6;k++)
{
scanf("%d",&a[k]);
}
quicksort(a,0,6);
inti;
for(i=0;i<6;i++)
printf("%4d",a[i]);
}
时间复杂性分析:
最坏情况下T(n)=O(
)
2、若有序列A={5,2,6,4,1,3},根据快速排序算法的思想,给出升序排序的过程。
排序过程如下:
(1)设置两个变量i,j,排序开始的时候i=0,j=n-1=5;
(2)以第一个数组元素5作为关键数据,赋值给key,即key=A[0]=5;
(3)从j开始向前搜索,由后开始向前搜索j--;找到第一个小于key的A[j],将A[j]和A[i]互换,即是3和5互换;
(4)从i开始向后搜索,由前向后i++,找到第一个大于key的A[i],将A[i]和A[j]互换;
(5)重复(3)、(4)直到i=j;
开始序列为526413i=0;j=n-1=5;关键字为5;
(1)5>3,将5和3的位置互换;序列变为326415
(2)2<5,所以不用交换位置,序列为326415
(3)6>5,所以将5和6互换位置,序列变为325416
(4)5>1,所以互换位置,序列变为321456
(5)4<5,所以不用互换位置,序列仍是321456
(6)再以3为关键字,分别与4,5,6比较,均不用互换位置
(7)3>1,互换位置后序列变为123456
(8)然后2<3也不必换位置,i=j比较结束,序列为123456
五、实验心得
贵州师范大学数学与计算机科学学院实验报告
课程名称:
算法设计与分析班级13计本实验日期:
2015/11/13
学号:
130702010047姓名:
二指导教师:
熊祥光成绩:
一、实验名称
矩阵连乘问题和0-1背包问题
二、实验目的及要求
1、掌握动态规划的基本思想;
2、采用动态规划思想,编程实现矩阵连乘算法和0-1背包算法;
3、能分析所设计算法的计算复杂性;
4、对于给定的实例,能给出相应算法的计算过程。
三、实验工具
XP系统或Win7系统,编程语言不限
四、实验内容
(一)、矩阵连乘问题
1、编程语言不限,实现矩阵连乘问题的动态规划算法并对算法的复杂性进行分析。
源程序:
#include
#defineN30
voidmatrixChain(intp[],intm[N+1][N+1],intb[N+1][N+1])//函数定义;
{
intn=N;
for(inti=1;i<=n;i++)
m[i][i]=0;
intr;
for(r=2;r<=n;r++)
{
inti;
for(i=1;i<=n-r+1;i++)
{
intj=i+r-1;
m[i][j]=m[i+1][j]+p[i-1]*p[i]*p[j];
b[i][j]=i;
intk;
for(k=i+1;k{
intd=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
if(d{
m[i][j]=d;
b[i][j]=k;
}
}
}
}
}
voidtraceback(inti,intj,intb[][N+1])
{
if(i==j)
{
printf("A%d",i);
}
else
{
printf("(");
traceback(i,b[i][j],b);
traceback(b[i][j]+1,j,b);
printf(")");
}
}
main()
{
intn;
inta[2*N];
intc[N+1],flag=1;
intm[N+1][N+1];
intb[N+1][N+1];
printf("请输入矩阵的个数:
");
scanf("%d",&n);
for(inti=0;i<=2*n-1;i++)
{
if(i%2==0)
{
printf("请输入A%d的行:
",(i/2)+1);
}
else
{
printf("列:
");
}
scanf("%d",&a[i]);
}
for(i=1;i<=2*n-2;i++)
{
if(i%2!
=0&&a[i]!
=a[i+1])
{
flag=0;
break;
}
}
intj;
for(j=1;j<=n-1;j++)
{
c[j]=a[2*j];
}
if(flag!
=0)
{
c[0]=a[0];
c[n]=a[2*n-1];
matrixChain(c,m,b);
printf("最优解的结构为:
\n");
traceback(1,n,b);
printf("\n");
printf("最小数乘次数为%d\n",m[1][n]);
}
else
{
printf("这%d个矩阵不能连乘!
\n",n);
}
return0;
}
两个矩阵能够相乘的条件是第一个矩阵的列要等于第二个矩阵的行,如下图所输入的矩阵的值就不能相乘。
算法复杂度分析:
算法matrixChain的主要计算量取决于算法中对r,i和k的3重循环。
循环体的计算量为O
(1),而3重循环的总次数为O(n3)。
因此算法的计算时间上界为O(n3)。
算法所占用的空间显然为O(n2)。
2、若A1的大小为30×20,A2的大小为20×5,A3的大小为5×15,A4的大小为15×20,A5的大小为20×20,A1的大小为20×35,根据矩阵连乘问题的动态规划的算法思想,给出最优计算次序的过程。
计算最优次序过程为:
A1
A2
A3
A4
A5
A6
30×20
20×5
5×15
15×20
20×20
20×35
根据公式:
m[1][2]=A1A2=30×20×5=3000
m[2][3]=A2A3=20×5×15=1500
m[3][4]=A3A4=5×15×20=1500,
m[4][5]=A4A5=15×20×20=6000
m[5][6]=A5A6=20×20×35=14000
m[1][3]=A1A2A3=min
=min{5250,10500}=5250
m[2][4]=A2A3A4=min
=min{7500,3500}=3500
m[3][5]=A3A4A5=min
=min{7500,3500}=3500
m[4][6]=A4A5A6=min
=min{16500,24500}=16500
=7500
=5500
=7000
=9500
=10500
=15250
最优解为:
(A1A2)(((A3A4)A5)A6)
(二)、0-1背包问题
1、编程语言不限,实现0-1背包问题的动态规划算法并对算法的复杂性进行分析。
源程序:
#include
intV[15][15];
intmax(intm,intg)//求最大值
{
if(m>=g)
returnm;//m表示物品的重量
elsereturng;//g表示背包的容量
}
intKnapSack(intn,intw[],intv[],intx[],intC)
{
inti,j;
for(i=0;i<=n;i++)
V[i][0]=0;//表示有物品i,但是背包容量为0
for(j=0;j<=C;j++)
V[0][j]=0;//表示背包有容量,但是没有物品
for(i=0;i<=n-1;i++)
for(j=0;j<=C;j++)
if(jV[i][j]=V[i-1][j];
else
V[i][j]=max(V[i-1][j],V[i-1][j-w[i]]+v[i]);
j=C;
for(i=n-1;i>=0;i--)
{
if(V[i][j]>V[i-1][j])
{
x[i]=1;//将物品i装入背包的情况
j=j-w[i];
}
else
x[i]=0;//物品i没有被装入背包
}
printf("选中的物品是:
\n");
for(i=0;iprintf("%d",x[i]);
printf("\n");
returnV[n-1][C];
}
main()
{
ints;
intw[15];
intv[15];
intx[15];
intn,i;
intC;
n=5;
printf("请输入背包的最大容量:
\n");
scanf("%d",&C);
printf("输入物品数:
\n");
scanf("%d",&n);
printf("请分别输入物品的重量:
\n");
for(i=0;iscanf("%d",&w[i]);
printf("请分别输入物品的价值:
\n");
for(i=0;iscanf("%d",&v[i]);
s=KnapSack(n,w,v,x,C);//函数调用
printf("最大物品价值为:
\n");
printf("%d\n",s);
}
算法复杂度分析:
从m(i,j)的递归式容易看出,算法Knapsack需要O(nc)计算时间;Traceback需O(n)计算时间;算法总体需要O(nc)计算时间。
当背包容量c很大时,算法需要的计算时间较多
2、若n=5,c=5,w={2,1,2,2,3},v={2,3,1,3,4},根据0-1背包问题的动态规划算法思想,给出构造最优解的过程。
(1)枚举法:
有5种物品,背包容量c=5
{x1,x2,x3,x4,x5}={0,0,0,0,0},{0,0,0,0,1},{0,0,0,1,0},{0,0,0,1,1},{0,0,1,0,0},{0,0,1,0,1},{0,0,1,1,0},{0,1,0,0,0},{0,1,0,0,1},{0,1,0,1,0},{0,1,0,0,0},{0,1,1,0,0},{0,1,0,0,0},{0,1,1,1,0},{1,1,0,1,0}
{x1,x2,x3,x4,x5}={1,1,0,1,0}
v1*x1+v2*x2+v3*x3+v4*x4+v5*x5=8
(2)构造最优解
5
4
3
2
1
012345
4
7
4
4
0
0
4
3
0
4
3
4
0
j
i
5
4
3
2
1
0
0
0
4
0
3
7
6
7
7
0
8
3
3
6
3
7
m[1][5]>m[2][5]物品1被选x[1]=1c=5-w[1]=3
m[2][3]>m[3][3]物品2被选x[2]=1c=3-w[2]=2
m[3][2]=m[4][2]物品3未被选x[3]=0
m[4][2]>m[5][2]物品4被选x[4]=1c=2-w[2]=0
m[5][2]=0物品5未被选x[5]=0
X1
X2
X3
x4
X5
1
1
0
1
0
贵州师范大学数学与计算机科学学院实验报告
课程名称:
算法设计与分析班级:
13计本实验日期:
2015/12/5
学号:
130702010047姓名陈美指导教师:
熊祥光成绩:
一、实验名称
贪心算法——最优装载问题
二、实验目的及要求
1、掌握贪心算法的基本思想;
2、利用贪心算法思想,编程实现最优装载问题;
3、能对所设计算法的计算复杂性进行分析;
4、对于给定的实例,能给出相应算法的计算过程。
三、实验工具
XP系统或Win7系统,编程语言不限
四、实验内容
1、编程语言不限,实现教材P95页的货船最优装载算法并对该算法的复杂性进行分析。
程序源代码如下:
#include
voidSort(int*w,int*t,intn)
{
inti,j,count=0;
int*s=newint[n+1];
for(i=1;i<=n;i++)
s[i]=w[i];
for(i=1;i<=n;i++)
t[i]=0;
for(i=0;i<=n;i++)
{
count=0;
for(j=0;j<=n;j++)
if(i!
=j)
if(s[i]>s[j])
count++;
while(t[count]!
=0)
count++;
t[count]=i;
}
}
voidloading(intw[],intx[],intc,intn)
{
int*t=newint[n+1];
Sort(w,t,n);//排序
for(inti=1;i<=n;i++)
{
x[i]=0;
}
for(intj=1;j<=n&&w[t[j]]<=c;j++)
{
x[t[j]]=1;
c=c-w[t[j]];
}
}
intmain()
{
intX[20],W[20],n,c;
printf("请输入船只载重:
");
scanf("%d",&c);
printf("请输入集装箱数量:
");
scanf("%d",&n);
printf("输入物品的重量序列:
");
for(inti=1;i<=n;i++)
{
scanf("%d",&W[i]);
}
loading(W,X,c,n);
printf("最优装载为");
for(intj=1;j<=n;j++)
{
printf("%d",X[j]);
}
printf("\n");
return0;
}
实验截图如下:
时间复杂度分析:
算法的主要计算量在于将集装箱依其重量从小到大排序,程序中有两个嵌套for循环,所以复杂性为:
O(n*n)。
2、假设某公司现有8个集装箱急需搬上一艘大货船,它们的重量分别是[W0,W2,…,W7]=[100,200,50,90,150,50,20,80],船只载重C=400。
求该条件下的最优装载问题。
(要求给出具体的过程)
解答过程如下:
从剩下的集装箱中,选择重量最小的集装箱。
这种选择次序可以保证所选的集装箱总重量最小,从而可以装载更多的集装箱。
根据这种贪心策略,首先选择最轻的集装箱,然后选择次轻的,如此下去直到所有集装箱均装上船或船上不能容纳其他集箱。
n=8,[W1,W2,…,W8]=[100,200,50,90,150,50,20,80],c=400。
利用贪心算法时,所考察集装箱的顺序为7,3,6,8,4,1,5,2。
集装箱7,3,6,8,4,1的总重量为390个单位且已被装载,剩下的装载能力