算法设计与分析C语言描述陈慧南版课后答案.docx

算法设计与分析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（x

elseif（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（x

elseif（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+n

intmid,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（left

elset=left-1;

if（k>cnt）{

if（cnt>0）

{

for（j=0;j

temp[j]=a[r];r++;

}

left=cnt;

k-=cnt;

}

else

{

temp[j]=b[i];

left=0;

k--;

}

}

else{

for（j=0;j

temp[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,j

If（（x[j]==i）||（abs（x[j]-j）==abs（j-k）））

Returnfalse;

Returntrue;

}

Voidnqueens（intk,intn,int*x）

{

For（inti=0;i

If（place（k,I,x））

{

X[k]=I;

If（k==n-1

{

For（i=0;i

Return;

}

Elsenqueens（k+1,n,x）

}

}

Voidnqueens（intn,int*x）

{

Nqueens（0,n,x）;