算法设计与分析C语言描述陈慧南版课后答案.docx
《算法设计与分析C语言描述陈慧南版课后答案.docx》由会员分享，可在线阅读，更多相关《算法设计与分析C语言描述陈慧南版课后答案.docx（15页珍藏版）》请在冰豆网上搜索。
算法设计与分析C语言描述陈慧南版课后答案
第一章
P15
1-3.最大公约数为1。
快1414倍。
主要考虑循环次数，程序1-2的while循环体做了10次，程序1-3的while循环体做了14141次（14142-2循环）
若考虑其他语句，则没有这么多，可能就601倍。
第二章
1~32
2-8.
（1）画线语句的执行次数为
logn。
（logn）。
划线语句的执行次数应该理解为一格整体。
2
ncg（n），即f（n）
（3）画线语句的执行次数为.n。
G，n）。
（4）
当n为-
奇数时画线语句的执行次数为
（n
i1）（n
3）
4
当n为,
偶数时画线语句的执行次数为
（n
i2）2
。
（n2）。
4
2-10.
（1）
2
当n1时，5n8n
2
5n2，
所
以，可选
c5，
no1
。
对于
nno，
f（n）
5n2
8n25n2,所以，5n2
8n
2
（n2）
。
（2）
当n
22
i8时，5n8n25n
2n
2
4n2，
所以，可选
c4
，no
8。
对于
nno,
f（n）
5n2
22
8n24n,所以，5n
8n
2
（n2）
。
（3）
由（1
）、
（2）可知，取g4，c2
5
，n。
8，
当nn0时,
有&n2
5n2
8n
2
qn2，所
以5n
28n
2
（n2）。
2-11.
（1）当
n
3时，logn
nlog3n，所以f（n）
20n
logn21n，g（n）
nlog3n2n。
可
选c
21
2，
no
3。
对于n
no，f（n）cg（n），即
f（n）
（g（n））。
注意：
是
f（n）和g（n）的关系。
（2）
当n
4
时，lognn
2
logn，所以f（n）
n2/log
nn2，g（n）nlog
22
nn。
可选c
1，
n°
4。
对于nn°，f（n）
（g（n））。
（3）
因为f（n）（logn）logn
nlog（logn），g（n）n/lognnlogn2。
当n
4时，f（n）nlog（logn）
（g（n））。
g（n）nlogn2n。
所以，可选c1,n4，对于nn°,f（n）cg（n），即f（n）
第二章
2-17.证明：
设
n2，贝Ui
logn。
Tn
2T
n2nlogn22T
ncn|n
22log-
2222
2nlogn
22T
n
2nlognIog2
2nlogn
22T
n
22nlogn2n
222T23
2nlog*22nlogn
2n
23T
n
23
2nlognIog4
22nlogn
2n
23T
n
歹
32nlogn2n
4n
LL
2kT
n
2k
2knlogn2n
4nL2nk
1
21t
22
iInlogn2n
4nL2ni
2
21
42nlognlogn1i
2i1n
2n
2nlog2
n2nlognlog
2n3logn2
n
2
nlognnlogn
当n2时，Tn2nlog2n。
所以，Tnnlog2n。
第五章
5-4.SolutionTypeDandC1（intleft,intright）
{
while（!
Small（left,right）&&left{
intm=Divide（left,right）;if（xelseif（x>P[m]）left=m+1;
elsereturnS（P）
}
}
5-7.template
intSortableList:
:
BSearch（constT&x,intleft,intright）const{
if（left<=right）
{
intm=（right+left）/3;
if（xelseif（x>l[m]）returnBSearch（x,m+1,right）;elsereturnm;
}
return-1;
}
第五章
9.
4
26
1357
证明：
因为该算法在成功搜索的情况下，关键字之间的比较次数至少为
logn，至多为logn1。
在
好、最坏情况的时间复杂度为logn
1
假定查找表中任何一个元素的概率是相等的，为-，那么,
n
11.
步数
0
1
2
3
4
5
初始时
1
1
1
1
1
1
[1
1]
1
[1
1]
OO
2
:
[1]
1
1
[1
1]
OO
3
1
1
1
[1
1]
OO
4
1
1
1
[1]
1
OO
排序结果
1
1
1
1
1
OO
步数
0
1
2
3
4
5
6
7
初始时
5
5
8
3
4
3
2
OO
1
[4
2
3
3]
5
[8
5]
OO
2
[3
2
3]
4
5
[8
5]
OO
3
J卩
2]
3
4
5
[8
5]
OO
4
[2]
3
3
4
5
[8
5]
OO
5
2
3
3
4
5
[5]
8
OO
排序结果
2
3
3
4
5
5
8
OO
12.
（1）证明：
当n0或n1或n2时，程序显然正确。
当n=right-left+1>2时，程序执行下面的语句：
intk=（right-left+1）/3;
StoogeSort（left,right-k）;StoogeSort（left+k,right）;
StoogeSort（left,right-k）;
1首次递归StoogeSort（left,right-k）;时，序列的前2/3的子序列有序。
2当递归执行StoogeSort（left+k,right）;时，使序列的后2/3的子序列有序，经过这两次递归排序，使原序
列的后1/3的位置上是整个序列中较大的数，即序列后1/3的位置上数均大于前2/3的数，但此时，前2/3
的序列并不一定是有序的。
3再次执行StoogeSort（left,right-k）;使序列的前2/3有序。
经过二次递归，最终使序列有序。
所以，这一排序算法是正确的。
（2）最坏情况发生在序列按递减次序排列。
0
1
0，
21，n
2n
3
3
1。
设n
i
23，
则i
logn
1
—。
2
Iog3
1
c2
n1
33
4,
19
4c“
n
3-
n1
n31LL
3
9
9
3i
i
2
n
3i1
3i2L
3
1
3i2
3i1
2
3i
logn1
3nIog311
——2—
222
Iog3
Iog31
n
Iog3
Iog31
n
冒泡排序最坏时间复杂度为
n，队排序最坏时间复杂度为nIogn，快速排序最坏时间复杂度为
nIogn。
所以，该算法不如冒泡排序，堆排序，快速排序。
13.template
select（T&x,intk）
{
if（m>n）swap（m,n）;
if（m+nintmid,Ieft=0,right=n-1,cnt=O,j=O,r=O;
for（inti=0;i{
while（k>0）
{
do
{
mid=（left+right）/2;
if（a[mid]elseif（a[mid]>b[i]）right=mid;else{cnt=mid;break;}}while（leftelset=left-1;
if（k>cnt）{
if（cnt>0）
{
for（j=0;jtemp[j]=a[r];r++;
}
left=cnt;
k-=cnt;
}
else
{
temp[j]=b[i];
left=0;
k--;
}
}
else{
for（j=0;jtemp[j]=a[r];r++;
}
left=cnt;
k-=cnt;
returntemp[k_1];
}
}
第八早
1•由题可得:
直P_P2_P3_P4_P5_P61051576183w0'则'w2'w3'w4'w5'w62357V41
21
最大收益为10515618355丄。
33
6-9.
普里姆算法。
因为图G是一个无向连通图。
所以n-1<=m<=n（n-1）/2;
O（n）<=m<=0（n2）;
克鲁斯卡尔对边数较少的带权图有较高的效率，而mn1.99n2，此图边数较多，接近完全图，
故选用普里姆算法。
6-10.
T仍是新图的最小代价生成树。
证明：
假设T不是新图的最小代价生成树，T'是新图的最小代价生成树，那么cost（T'）有
cost（T-c）-1）的最小代价生成树矛盾。
所以假设不成立。
证毕。
第七章
1.Bcost（1,0）=0;
Bcost（2,1）=c（1,1）+Bcost（1.0）=5
Bcost（2,2）=c（1,2）+Bcost（1,0）=2
Bcost（3,3）=min{c（2,3）+Bcost（2,2）,c（1,3）+Bcost（2,1）}=min{6+2,3+5}=8
Bcost（3,4）=c（2,4）+Bcost（2,2）=5+2=7
Bcost（3,5）=min{c（1,5）+Bcost（2,1）,c（2,5）+Bcost（2,2）}=min{3+5,8+2}=8
Bcost（4,6）=min{c（3,6）+Bcost（3,3）,c（4,6）+Bcost（3,4）,c（5,6）+Bcost（3,5）}=min{1+8,6+7,6+8}=9
Bcost（4,7）=min{c（3,7）+Bcost（3,3）,c（4,7）+Bcost（3,4）,c（5,7）+Bcost（3,5）}=min{4+8,2+7,6+8}=9
Bcost（5,8）=min{c（6,8）+Bcost（4,6）,c（7,8）+Bcost（4,7）}=min{7+9,3+9}=12
2.向后递推的计算过程如上题所示向前递推过程如下：
cost（5,8）=0cost（4,6）=7,cost（4,7）=3cost（3,3）=min{1+cost（4,6）,4+cost（4,7）}=7,cost（3,4）=min{6+cost（4,6）,2+cost（4,7）}=5cost（3,5）=min{6+cost（4,6）,2+cost（4,7）}=5cost（2,1）=min{3+cost（3,3）,3+cost（3,5）}=8cost（2,2）=min{6+cost（3,3）,8+cost（3,5）,5+cost（3,4）}=10cost（1,0）=min{5+cost（2,1）,2+cost（2,2）}=12
所以，d（4,6）=d（4,7）=8,d（3,3）=d（3,4）=d（3,5）=7,d（2,1）=5,d（2,2）=4,d（1,0）=2
从s到t的最短路径为（0,d（1,0）=2,d（2,2）=4,d（3,4）=7,d（4,7）=8）,路径长为12。
第七章
9.cha
rA[
8]={
<
0'
'x
J
z',
y'
'z
J
z'
>>>>、
'y','x'}
B[
8]={
（
0'
J
z',
'x'
J
y'
J
y',
z'
J
x','z'}
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
1
1
1
1
1
0
2
1
3
3
3
1
3
0
1
1
1
1
2
2
2
0
1
2
2
2
1
3
1
0
1
1
2
2
2
2
2
0
2
2
1
1
2
2
2
0
1
1
2
2
3
3
3
0
1
2
2
2
1
3
1
0
1
1
2
2
3
3
4
0
1
2
2
2
1
2
1
0
1
1
2
3
3
3
4
0
2
2
1
1
2
2
2
0
1
2
2
3
3
4
4
0
2
1
2
2
2
1
2
（a）c[i][j]（b）s[i][j]
所以，最长公共字串为（x,y,z,z）。
第七章
11.voidLCS:
:
CLCS（inti,intj）
{
if（i==0||j==0）return;
if（c[i][j]==c[i-1][j-1]+1）
{
CLCS（i-1,j-1）;
Cout<}
elseif（c[i-1][j]>=c[i][j-1]）CLCS（i-1,j）;
elseCLCS（i,j-1）;
}12.intLCS:
:
LCSLength（）
{
for（inti=1;i<=m;i++）c[i][0]=0;
for（i=1;i<=n;i++）c[0][i]=0;
for（i=1;i<=m;i++）
for（intj=1;j<=n;j++）
if（x[i]==y[j]）c[i][j]=c[i-1][j-1]+1;
elseif（c[i-1][j]>=c[i][j-1]）c[i][j]=c[i-1][j];
elsec[i][j]=c[i][j-1];
returnc[m][n];
}
10
15.S1{（0,0）},S10{（10,2）},
01
S0{（0,0）,（10,2）},S11{（15,5）,（25,7）},
S1{（0,0）,（10,2）,（15,5）,（25,7）},S12{（6,8）,（16,10）,（21,13）,（31,15）},
S2{（0,0）,（6,8）,（16,10）,（21,13）,（31,15）}S13{（9,1）,（15,9）,（25,11）,（30,14）,（40,16）}
3
S3{（0,0）,（6,8）,（15,9）,（16,10）,（21,13）,（30,14）,（31,15）}
8-1．状态空间：
描述问题的各种可能的情况，一种情况对呀状态空间的一个状态。
显示约束：
用于规定每个xi取值的约束条件称为显示约束隐式约束：
用于判定一个候选解是否为可行解的条件问题状态：
在状态空间树中的每个节点称为一个问题状态解状态：
如果从根到树中某个状态的路径代表一个作为候选解的元组，则该状态为解状态答案状态：
如果从根到树中某个状态的路径代表一个作为可行解的元组，则该状态为解状态。
活结点：
回溯法从开始结点出发，以深度优先的方式搜索整个解空间，这个开始结点就成为一个活结点。
未检测的结点称为活结点
扩展结点：
算法从x出发，访问x的摸个后继结点y,则x被称为扩展结点
Y的子树
约束函数：
一个约束函数是关于部分向量的函数Bk（x0,x1xk）,它被定义为：
如果可以判定
上不含任何答案状态,则Bk（x0,x1xk）为false,否则为true.
剪枝函数：
约束函数和限界函数的目的相同,都是为了剪去不必要搜索的子树,减少问题求解所需实际生成的状态节点数,他们统称为剪枝函数
8-2
boolplace（intk,int,I,int*x）{
For（intj=0,jIf（（x[j]==i）||（abs（x[j]-j）==abs（j-k）））
Returnfalse;
Returntrue;
}
Voidnqueens（intk,intn,int*x）
{
For（inti=0;iIf（place（k,I,x））
{
X[k]=I;
If（k==n-1
{
For（i=0;iReturn;
}
Elsenqueens（k+1,n,x）
}
}
Voidnqueens（intn,int*x）
{
Nqueens（0,n,x）;
升级会员 