算法设计与分析计算题

《算法设计与分析》

一、 排序和查找是经常遇到的问题。按照要求完成以下各题：

(1)对数组A={15，29，135，18，32，1，27，25，5}，用快速排序方法将其排成递减序。 解：（1）第一步：15 29 135 18 32 1 27 25 5 第二步：29 135 18 32 27 25 15 1 5

第三步：135 32 29 18 27 25 15 5 1 第四步：135 32 29 27 25 18 15 5 1

(2)请描述递减数组进行二分搜索的基本思想，并给出非递归算法。

解：基本思想：首先将待搜索元素v 与数组的中间元素2n A ??????进行比较，如果2n v A ??

>????，

则在前半部分元素中搜索v ；若2n v A ??

=????，则搜索成功；否则在后半部分数组中搜索v 。

非递归算法：

输入：递减数组A[left:right]，待搜索元素v 。

输出：v 在A 中的位置pos ，或者不在A 中的消息（-1）。 步骤：

int BinarySearch(int A[],int left,int right,int v) {

int mid;

while (left<=right) {

mid=int((left+right)/2); if (v==A[mid]) return mid;

else if (v>A[mid]) right=mid-1; else left=mid+1; }

return -1; }

(3)给出上述算法的递归算法。

解：输入：递减数组A[left:right]，待搜索元素v 。 输出：v 在A 中的位置pos ，或者不在A 中的消息（-1）。 步骤：【3分】

int BinarySearch(int A[],int left,int right,int v) {

int mid;

if (left<=right) {

mid=int((left+right)/2); if (v==A[mid]) return mid;

else if (v>A[mid]) return BinarySearch(A,left,mid-1,v); else return BinarySearch(A,mid+1,right,v); } else

return -1;

}

(4)使用上述算法对（1）所得到的结果搜索如下元素，并给出搜索过程：18，31，135。 解：搜索18：首先与27比较，18<27，在后半部分搜索；再次与18比较，搜索到，返回5。 搜索31：首先与27比较，31>27，在前半部分搜索；再次32比较，31<32，在后半部分搜索，与29比较，31>29，此时只有一个元素，未找到，返回-1。

搜索135：首先与27比较，135>27，在前半部分搜索；再次32比较，135>32，在前半部分搜索；与135比较，相同，返回0。

二、排序和查找是常用的计算机算法。按照要求完成以下各题：

（1）对数组A={15，9，115，118，3，90，27，25，5}，使用合并排序方法将其排成递减序。 （2）若改变二分搜索法为三分搜索法，即从一个递减序列A 中寻找元素Z ，先与元素[]3

n

A 比

较，若[]3n Z A ，则在前面[]3n 个元素中寻找Z ；否则与2[]3

n

A 比较，总之使余下的序列为[]

3n 个元素。给出该方法的伪代码描述。

(3)使用上述算法对（1）所得到的结果搜索如下元素，并给出搜索过程：118，31，25。 解：（1）第一步：15 9 115 118 3 90 27 25 5

第二步：15 9 118 115 90 3 27 25 5 第三步：118 115 15 9 90 27 25 3 5 第四步：118 115 90 27 25 15 9 3 5 第五步：118 115 90 27 25 15 9 5 3

（2）输入：递减数组A[left:right]，待搜索元素v 。 输出：v 在A 中的位置pos ，或者不在A 中的消息（-1）。 步骤：

int BinarySearch(int A[],int left,int right,int v) {

int mid;

while (left<=right) {

first=left+(right-left+1)/3; second=left+(right-left+1)/3*2; if (v==A[first]) return first;

else if (v>A[first]) right=first-1;

else if (v==A[second]) return second;

else if (v>A[second]) {left=first+1;right=second-1;}

else left=second+1;

}

return -1;

}

（3）搜索118：118>27，所以right＝3；118>115，所以right＝1；118＝118，找到。

搜索31：31>27，所以right＝3；31<90，所以left=4，结束，未找到。

搜索25：9<25<27，所以left=5，right=6；25＝25，找到。

三、Dijkstra算法求单源最短路径

d[u]:s到u的距离 p[u]:记录前一节点信息

Init-single-source(G,s)

for each vertex v∈V[G]

do { d[v]=∞; p[v]=NIL }

d[s]=0

Relax(u,v,w)

if d[v]>d[u]+w(u,v)

then { d[v]=d[u]+w[u,v];

p[v]=u

}

dijkstra(G,w,s)

Init-single-source(G,s)

S=Φ

Q=V[G]

while Q<> Φ

do u=min(Q)

S=S∪{u}

for each vertex v∈adj[u]

do Relax(u,v,w)

四、对于下图使用Dijkstra算法求由顶点a到其他各个顶点的最短路径。并给出求各个顶点对之间的最短路径的算法思想。

步骤 V1 V2 E1E2

1. {a} {b} {} {ab}

2. {a,b} {d} {ab} {bd}

3. {a,b,d} {c,f} {ab,bd} {dc,df}

4. {a,b,d,c} {f} {ab,bd} {df}

5. {a,b,c,d,f} {e} {ab,bd,dc,df} {fe}

6. {a,b,c,d,e,f} {g} {ab,bd,dc,df,fe} {eg}

7. {a,b,c,d,e,f,g} {h} {ab,bd,dc,df,fe,eg} {gh}

8. {a,b,c,d,e,f,g,h} {} {ab,bd,de,df,fe,eg,gh} {}

结果：从a到h的最短路径为a b d f e g h

→→→→→→，权值为18。

五、问题描述：有不同价值、不同重量的物品n件，求从这n件物品中选取一部分物品的选择方案，使选中物品的总重量不超过指定的限制重量，但选中物品的价值之和最大。

#include

void main()

{

int m,n,i,j,w[50],p[50],pl[50],b[50],s=0,max;

printf("输入背包容量m,物品种类n :");

scanf("%d %d",&m,&n);

for(i=1;i<=n;i=i+1)

{

printf("输入物品的重量W和价值P :");

scanf("%d %d",&w[i],&p[i]);

pl[i]=p[i];

s=s+w[i];

}

if(s<=m)

{

printf("whole choose\n");

//return;

}

for(i=1;i<=n;i=i+1)

{

max=1;

for(j=2;j<=n;j=j+1)

if(pl[j]/w[j]>pl[max]/w[max])

max=j;

pl[max]=0;

b[i]=max;

}

for(i=1,s=0;s

s=s+w[b[i]];

if(s!=m)

w[b[i-1]]=m-w[b[i-1]];

for(j=1;j<=i-1;j=j+1)

printf("choose weight %d\n",w[b[j]]);

六、假设有7个物品，它们的重量和价值如下表所示。若这些物品均不能被分割，且背包容量M＝150，使用回溯方法求解此背包问题。请写出状态空间搜索树（20分）。

解：贪心算法：（1）标准：重量、价值和单位价值。

（2）使用重量从小到大：FGBAEDC。得到贪心解为：FGBAE全部放入，而D放入20%，得到价值为165。

使用价值从大到小：DFBEGCA，得到贪心解为：DFBE全部放入，而G放入80%，得到价值为：189。

使用单位价值从大到小：FBGDECA，得到贪心解为：FBGD全部放入，而E放入87.5%，得到价值为190.625。

（3）显然使用单位价值作为标准得到的是最优解。

回溯法：按照单位效益从大到小依次排列这7个物品为：FBGDECA。将它们的序号分别记为1～7。则可生产如下的状态空间搜索树。其中各个节点处的限界函数值通过如下方式求得：

5x =6x =7x =a ．1501154040305035190.62540

-++++?= 7(1,1,1,1,,0,0)8

b. 1501154040305030177.560

-++++?=7(1,1,1,1,0,,0)12

c ．4040305010170++++=

(1,1,1,1,0,0,1)

d. 1501054040303530167.560

-++++?= 3(1,1,1,0,1,,0)4

e. 150130404050353017560

-++++?=

1

(1,1,0,1,1,,0)3

f. 1501304040503510170.7135

-++++?=

4(1,1,0,1,1,0,)7

g. 40405030160+++=

(1,1,0,1,0,1,0)

h. 1501404040353010146.8535

-++++?=

2

(1,1,0,0,1,1,)7

i.1501254030503530167.560-++++?=5(1,0,1,1,1,,0)12

j. 150145

4030503530157.560-++++?

=1(0,1,1,1,1,,0)12

在Q 1处获得该问题的最优解为(1,1,1,1,0,0,1)，背包效益为170。即在背包中装入物品F 、B 、G 、D 、A 时达到最大效益，为170，重量为150。

七、分别用贪心算法、动态规划法、回溯法设计0-1背包问题。要求：说明所使用的算法策略；写出算法实现的主要步骤；分析算法的时间

（1）贪心算法 O（nlog（n））

首先计算每种物品单位重量的价值Vi/Wi，然后，依贪心选择策略，将尽可能多的单位重量价值最高的物品装入背包。若将这种物品全部装入背包后，背包内的物品总重量未超过C，则选择单位重量价值次高的物品并尽可能多地装入背包。依此策略一直地进行下去，直到背包装满为止。

具体算法可描述如下：

void Knapsack(int n,float M,float v[],float w[],float x[])

{Sort(n,v,w);

int i;

for (i=1;i<=n;i++) x[i]=0;

float c=M;

for (i=1;i<=n;i++)

{if (w[i]>c) break;

x[i]=1;

c-=w[i];

}

if (i<=n) x[i]=c/w[i];

}

（2）动态规划法 O(nc)

m(i，j)是背包容量为j，可选择物品为i，i+1，…，n时0-1背包问题的最优值。

由0-1背包问题的最优子结构性质，可以建立计算m(i，j)的递归式如下。

void KnapSack(int v[],int w[],int c,int n,int m[][11])

{int jMax=min(w[n]-1,c);

for (j=0;j<=jMax;j++) /*m(n,j)=0 0=

m[n][j]=0;

for (j=w[n];j<=c;j++) /*m(n,j)=v[n] j>=w[n]*/

m[n][j]=v[n];

for (i=n-1;i>1;i--)

{ int jMax=min(w[i]-1,c);

for (j=0;j<=jMax;j++) /*m(i,j)=m(i+1,j) 0=

m[i][j]=m[i+1][j];

for (j=w[i];j<=c;j++)/*m(n,j)=v[n] j>=w[n]*/

m[i][j]=max(m[i+1][j],m[i+1][j-w[i]]+v[i]);

}

m[1][c]=m[2][c];

if(c>=w[1])

m[1][c]=max(m[1][c],m[2][c-w[1]]+v[1]);

}

（3）回溯法 O(2n)

cw:当前重量 cp:当前价值 bestp ：当前最优值 void backtrack(int i) //回溯法 i 初值1

{ if(i > n) //到达叶结点

{ bestp = cp; return; } if(cw + w[i] <= c) //搜索左子树 { cw += w[i];

cp += p[i]; backtrack(i+1);

cw -= w[i];

cp -= p[i]; }

if(Bound(i+1)>bestp) //搜索右子树

backtrack(i+1); }

八、已知1()*()i i k k ij r r A a +=，k =1，2，3，4，5，6，r 1=5，r 2=10，r 3=3，r 4=12，r 5=5，r 6=50，

r 7=6，求矩阵链积A 1×A 2×A 3×A 4×A 5×A 6的最佳求积顺序。（要求：给出计算步骤）

因此，最佳乘积序列为（A 1A 2）（（A 3A 4）（A 5A 6））

，共执行乘法2010次。

九、回答如下问题：

（1） 什么是算法？算法的特征有哪些？ 答：算法是解决某类问题的一系列运算的集合。

特征：具有有穷行、可行性、确定性、0个或者多个输入、1个或者多个输出。

（2） 什么是P 类问题？什么是NP 类问题？请描述集合覆盖问题的近似算法的基本思想。 解：用确定的图灵机可以在多项式实践内可解的判定问题称为P 类问题。 用不确定的图灵机在多项式实践内可解的判定问题称为P 类问题。

集合覆盖问题的近似算法采用贪心思想：对于问题，每次选择F 中覆盖了尽可能多的未被覆盖元素的子集S ，然后将U 中被S 覆盖的元素删除，并将S 加入C 中，最后得到的C 就是近似最优解。

十、、多段图问题：设G ＝(V ，E)是一个赋权有向图，其顶点集V 被划分成k>2个不相交的子集V i ：1i k ≤≤，其中，V 1和V k 分别只有一个顶点s （称为源）和一个顶点t （称为汇），图中所有的边（u,v ），i u V ∈，1i v V +∈。求由s 到t 的最小成本路径。（25分）

a) 给出使用动态规划算法求解多段图问题的基本思想。 b) 使用上述方法求解如下多段图问题。

s t

V1V2V3V4V5

解：（1）基本思想：设P(i,j)是从Vi 中的节点j 到汇点t 的最小成本路径，Cost(i,j)是其成本。则i+1Cost(i,j)=min{c(j,h)+Cost(i+1,h)|h V ,(j,h)E}∈∈。边界条件是（1）若h=t ，则Cost(h,t)＝0；（2）Cost(k-1,j)＝c(j,t)。 （2）求解过程可以表示为：

s t

V1V2V3V4V5

其中每个节点标示的序偶(p,q)中，p 表示节点到t 的成本，q 表示后继节点的编号。从而，最优路径为：1→2→7→10→12和1→3→6→10→12，成本为16。

十一．设x 1、x 2、x 3是一个三角形的三条边，而且x 1+x 2+x 3=14。请问有多少种不同的三角形？给出解答过程。

解：由于x 1、x 2、x 3是三角形的三条边，从而x i +x j >x k ，|x i -x j |

1+x 2+x 3=14可知1

x 3

即有4个可行解：（6，6，2），（6，5，3），（6，4，4，）（5，5，4）。

十二、设数组A 有n 个元素，需要找出其中的最大最小值。（20分） (1)请给出一个解决方法，并分析其复杂性。

(2)把n 个元素等分为两组A1和A2，分别求这两组的最大值和最小值，然后分别将这两组的最大值和最小值相比较，求出全部元素的最大值和最小值。如果A1和A2中的元素多于两个，则再用上述方法各分为两个子集。直至子集中元素至多两个元素为止。这是什么方法的思想？请给出该方法的算法描述，并分析其复杂性。

解：（1）基本思想：从头到尾逐个扫描，纪录最大和最小元素。

输入：具有n个元素的数组

输出：最大值和最小值

步骤：

void FindMaxMin(int A[], int n, int max, int min)

{

max=min=A[0];

for (i=1;i

{

if (A[i]>max) max=A[i];

if (A[i]

}

}

复杂性分析：由于是从头到尾扫描各个元素，而每个元素都要与max和min比较一遍，从而时间复杂性为：O(n)。

（2）void FindMaxMin(int left,int right, int max, int min) {

if (left==right) max=min=A[left];

else if (left=right-1) {

max=(A[left]

min=( A[left]

}

else{

mid=(left+right)/2;

FindMaxMin(left,mid,gmax,gmin);

FindMaxMin(mid+1,right,hmax,hmin);

max=(gmax

min=(gmin

}

}

十三、15谜问题：在一个4×4的方格的棋盘上，将数字1到15代表的15个棋子以任意的顺序置入各方格中，空出一格。要求通过有限次的移动，把一个给定的初始状态变成目标状态。移动的规则是：每次只能把空格周围的四格数字（棋子）中的任意一个移入空格，从而形成一个新的状态。为了有效的移动，设计了估值函数C1(x)，表示在结点x的状态下，没有到达目标状态下的正确位置的棋子的个数。

请使用该估计函数，对图示的初始状态，给出使用分支限界方法转换到目标状态的搜索树。

初始状态 目标状态

十四、编写计算斐波那契（Fibonacci ）数列的第n 项函数fib （n ）

斐波那契数列为：0、1、1、2、3、……，即： fib(0)=0; fib(1)=1;

fib(n)=fib(n-1)+fib(n-2) （当n>1时）。 写成递归函数有： int fib(int n)

{ if (n==0) return 0; if (n==1) return 1;

if (n>1) return fib(n-1)+fib(n-2); }

十五、求证：O(f(n))+O(g(n)) = O(max{f(n),g(n)})

7