算法设计与分析练习题

算法设计与分析练习题

1. 仅使用Ο、Ω、Θ和o 的定义，证明下列各式成立。 1) 5n 2 – 6n = Θ(n 2) 2) n!= Ο(n n )

3) 2n 22n + nlogn =Θ(n 22n )

4) i 2 = Θ(n 3

) 5) i 3 = Θ(n 4) 6) + 6 * 2n

=Θ 7) n 3 + 106n 2 =Θ(n 3) 8) 6n 3/(logn + 1) =Ο(n 3) 9) n 1.001 + nlogn =Θ(n 1.001) 10) n

k+ε

+ n k logn =Θ(n

k+ε

)，k ≥0，ε＞0

2. 采用定理2.2、2.4和2.6，证明第1题的所有式子成立。

3. 证明以下等式不成立。 1) 10n 2+9=Ο(n) 2) n 2logn=Θ(n 2) 3) n 2/logn =Θ(n 2) 4) n 32n +6n 23n =Ο(n 32n )

4. 证明当且仅当 lim f(n)/g(n)=0时，f(n)=o(g(n))。

5. 下面哪些规则是正确的？为什么？

1) {f(n)=Ο(F(n))，g(n)=Ο(G(n))} → f(n)/g(n)=Ο(F(n)/G(n)) 2) {f(n)=Ο(F(n))，g(n)=Ο(G(n))} → f(n)/g(n)=Ω(F(n)/G(n)) 3) {f(n)=Ο(F(n))，g(n)=Ο(G(n))} → f(n)/g(n)=Θ(F(n)/G(n)) 4) {f(n)=Ω(F(n))，g(n)=Ω(G(n))} → f(n)/g(n)=Ω(F(n)/G(n)) 5) {f(n)=Ω(F(n))，g(n)=Ω(G(n))} → f(n)/g(n)=Ο(F(n)/G(n)) 6) {f(n)=Ω(F(n))，g(n)=Ω(G(n))} → f(n)/g(n)=Θ(F(n)/G(n))

n →∞

（n ） 2n

n 2n

n

i=0 ∑ n

i=0

∑

7){f(n)=Θ(F(n))，g(n)=Θ(G(n))} → f(n)/g(n)=Θ(F(n)/G(n))

8){f(n)=Θ(F(n))，g(n)=Θ(G(n))} → f(n)/g(n)=Ω(F(n)/G(n))

9){f(n)=Θ(F(n))，g(n)=Θ(G(n))} → f(n)/g(n)=Ο(F(n)/G(n)) 6．计算以下函数的渐进复杂性，设计一个频率表加以说明。

1).SelectionSort(a[],int n)

2).InsertionSort(a[],int n)

3).BubbleSort(a[],int n)

4) 判断下列算法的渐进时间复杂度

Status CharLoopCheck() {

InitStack(S);InitQueue(Q);

C=getchar(); //读取一个字符。或者从文件上读入；或者从键盘上读入。

While(c!=?@?) {

Push(S,c);

EnQueue(Q,c);

C=getchar();

};//while

while(!empty(s)) {

pop(s,x);

Dequeue(Q,y);

if(x!=y) return …Error?;

};while

if(!empty(s) || !empty(Q)) {return …Error?;}

else

return …ok?

}// CharLoopCheck

7. 某算法的计算时间可用下面的递推关系式描述。试采用迭代的方式求解该关系式，并用大写О表示解(要求给出详细的推导过程)。

a n=1，a为常数

T(n)=

2T(n/2) + c*n n>1，c为常数

8. 折半查找过程的判定树上，定义根结点到每个内部结点(查找成功的结点)的路径长度之和为内部路径长度，记为I ；定义根结点到每个外部结点(查找不成功的结点)的路径长度之和外部路径长度，记为E 。

试证明：具有n 个内部结点的这样的判定树，满足E = I + 2n 。 9.已知f(n)=О(log 2n)，求证：f(n)=О(log k n)，k ＞1。

10. 根据大写О、Ω、Θ、小写o 的定义，计算给定函数的渐进表示。

请大家熟练掌握大写О、Ω、Θ、小写o 定义，并加以灵活应用。

例如，

则，根据定义有：

f(n)= О(?)，f(n)= Ω(?)。 11. 阅读下面的算法，并回答给定的问题。

注意，行号是为了说明问题而设置，它不属于算法本身。

void ABC(A ，n) {

//A(0:n)是一个一维数组，共有n 个可比较值大小的元素； //且A(0)未存放元素；变量x 是与A(i)同类型的数据元素。

1 int i, j ；

2 for(j=2；j<=n ；j++) {

3 i=j-l ；

4 A[0]=A[j]；

5 while(A[0]

6 x=A[i+1]；

7 A[i+1]=A[i]；

8 A[i]=x ；

9 i=i-1； 10 }；//while 11 A[i+1]= A[0]； 12 }；//for 13 }//ABC

问题：

① 第4行的A(0)的作用是什么？利用A(0)对算法有何影响？ ② 整个算法的功能是什么？ ③ 程序中变量x 是否可省，为什么？

④ 给出while 语句的最少执行次数的示例（列出数组A 的数据元素例子）

n 2 ，n 为正奇数 令f(n)=

n 3

，n 为正偶数

12. 作业中的相关习题要掌握（各种概念题、分析算法题及证明题等）。算法题分为阅读程序并解释程序的功能、根据题意编写算法、根据题意完成算法等几种类型。内容分布在分治法、贪婪法及动态规划法等典型问题中。回溯法也非常有用，请大家注意掌握。

13.下面的算法是依据分治策略设计出来的，仔细阅读该算法回答下列问题(行号是为了说明问题而设置，它不属于算法本身)。

行号 Void ABC(int w[]，int n，int &p，int &q) {

1 //w[0:n-1]中存放了n个整数。p,q是用于返回结果的两个变量

2 if(n<1) return false；

3 if(n==1) { p = q = 0；return true；}

4 int s；

5 if(n％2) ｛ p = q = 0；s = 1；｝

6 else {

7 if(w[0]>=w[1]) { p = 1；q = 0；}

8 else { p = 0；q = 1；}

9 s = 2；

10 ｝；

11 for(i=s；i

12 if(w[i]>w[i+1]) {if(w[i]>w[q]) q=i；if(w[i+1]

13 else｛if(w[i+1]>w[q]) q=i+1；if(w[i]

14 ｝；//for

15 return true；

16 ｝//ABC

问题：

①算法完成什么样的功能？当返回true时，p,q的返回值分别是什么？

②算法中哪个语句是出于对算法健壮性的考虑而设置的？

③对不同的n，讨论算法的比较次数。

14.依据贪婪法求解问题的思想，编写一个求解下列问题的算法。

设某币种有面额为25分、10分、5分、1分的四种硬币，1元钱等于100分。当希望找给顾客小于1元钱的零钱时，如何选择硬币种类才能够使得找给顾客的硬币数量最少。假设各种面额硬币的数量足够多。利用已经给出的部分代码，写出该问题的完整C语言算法。同时，假设需要找给顾客67分钱，请依据你的算法，给出找零钱的方案。

main()

{

int a[3]={25,10,5,1}； // a[0:3]存放硬币的不同面额

int b[4]； // b[0:3]存放对应硬币的数量(按面额由大到小)

int s； // 存放零钱总数

int i； // 循环控制变量

printf(“请输入零钱总数：”)；

scanf(“%d”,&s)；//输入零钱总数，然后在下面补充必要代码，完成整个算法

for(i=0；i<4；i++) printf(“面额为%d的硬币需要%d枚 \n”，a[i]，b[i])；

}//main

15. 依据所给的算法思路，在划线处填写适当的语句以完成整个算法。

问题：求已知两字符序列A和B的最长公共字符子序列。

定义：1. 从给定的字符序列中随意地(不一定是连续的一段)去掉若干字符(可能一个也不去掉)后形成的字符序列为给定字符序列的子序列。

例如，令X=’FEGDAADWS’，Y=’FEAD’，则Y是X的一个子序列。

2. 若Z既是字符序列A的子序列，又是字符序列B的子序列，则称Z是A和B的

公共子序列。

算法描述如下：

设A＝?a0,a1,…,a m-1?，B＝?b0,b1,…,b n-1?，Z＝?z0,z1,…,z k-1?是A、B的最长公共子序列，则有如下性质：

①如果a m-1=b n-1，则z k-l＝a m-1＝b n-1，且?z0,z1,…,z k-2?是?a0,a1,…,a m-2?和?b0,b1,…,b n-2?的一个最长公共子序列；

②如果a m-1≠b n-1，则若z k-1≠a m-1，蕴含?z0,z1,…,z k-1?是?a0,a1,…,a m-2?和?b0,b1,…,b n-1?的一个最长公共子序列；

③如果a m-1≠b n-1，则若z k-1≠b n-1，蕴含?z0,z1,…,z k-1?是?a0,a1,…,a m-1?和?b0,b1,…,b n-2?的一个最长公共子序列；

即，在找A和B的公共子序列时，如有a m-1=b n-1，则进一步解决一个子问题，即找?a0,a1,…,a m-2?和?b0,b1,…,b n-2?的一个最长公共子序列；如果a m-1≠b n-1，则要解决两个子问题，即找出?a0,a1,…,a m-2?和?b0,b1,…,b n-1?的一个最长公共子序列，和找出?a0,a1,…,a m-1?和?b0,b1,…,b n-2?的一个最长公共子序列，再取两者中的较长者作为A和B的最长公共子序列。

设c[i][j]为序列?a0,a1,…,a i-1?和?b0,b1,…,b j-1?的最长公共子序列的长度，则c[i][j] 计算的递归定义如下：

① c[i][j]=0，如果i=0，或j＝0；

② c[i][j]=c[i-1][j-1]＋1，如果i,j>0，且a[i-1]=b[j-1]；

③ c[i][j]=max{c[i][j-1],c[i-1][j]}，如果i,j>0，且a[i-1]≠b[j-1]。

依据上述思路的算法如下： # include # include

# define n 100 //假设串的最大长度为100 char a[n]，b[n]，str[n]；

int lcs_len(char *a ，char *b ，int c[n][n])

{

int m ＝strlen(a)，n ＝strlen(b)，i ，j ； for(i ＝0；i<=m ；i++) c[i][0]＝0；

for(j ＝1；j<=n ；j++) A ； //最长公共子序列的长度初始化 for(i ＝1；i<=m ；i++)

for(j ＝1；j<=n ；j++)

if(a[i-1]==b[j-l]) c[i][j] = c[i-1][j-1]+l ； else if(c[i-1][j] >= c[i][j-1])

c[i][j] = B ；

；

return C ；//返回最长公共子序列的长度

}

char *build-lcs(char s[],char *a,char *b) {

int k ，i=strlen(a)，j=strlen(b)，c[n][n]； k = lcs_len(a ，b ， D )； s[k] = …\0?； while(k>0)

if(c[i][j]==c[i-1][j]) i--；

else if(c[i][j]==c[i][j-1]) E ；

else { s[--k] = a[i-1]；

i--；j--； }；

return s ； }

void main() {

printf(“Enter two string(<％d)！\n ”， n)； scanf(“％s ％s ”，a ，b)；

printf(“LCS=％s\n ”，build_lcs(str ，a ，b))；

16. 试证明，对于函数f(n)和g(n)，若lim g(n)/f(n)存在，则f(n)＝Ω(g(n))当

且仅当存在确定的常数c ，有lim g(n)/f(n)≤c 。

17. 证明：如果一个算法在平均情况下的计算时间复杂度为θ(g(n))，则该算法在最坏情况下所需的时间是Ω(g(n))。 18.证明：n!=О(n n ) 19. 用贪婪法解装箱问题。

装箱问题可简述如下：设有编号为1，…，n 的n 种物品，体积分别为v 1，v 2，…，v n 。将这n 种物品装到容量都为V 的若干箱子里。约定这n 种物品的体积均不超过V ，即对于1≤i≤n，有0

n→∞

n→∞

的箱子数目可能不同，装箱问题要求使装尽这n种物品的箱子数要少。

设n件物品的体积已按从大到小排好序，即有：v1≥v2≥…≥v n。装箱算法简单描述如下：

{ 输入箱子的容积；

输入物品种数n；

按体积从大到小顺序，输入各物品的体积；

预置已用箱子链为空；预置已用箱子计数器box_count为0；

for(i=1；i<=n；i++) { //物品i按以下步骤装箱

从已用的第一只箱子开始，顺序寻找能放入物品i的箱子j；

if(已用箱子都不能再放物品i) { 另用一只箱子，并将物品i放入该箱子；box_count++；}

else 将物品i放入箱子j；}

}

以下程序是按照以上算法编写的，请在划线的空白处填入适当的语句以完成该程序，并举例说明该算法未必能够找到最优解。

#include

#include

typedef struct ele { //物品结构信息

int vno ；//物品号

struct ele *link；//另一物品的指针

}ele；

typedef struct hnode {

int remainder；//箱子尚剩空间

ele *head；//箱内物品链的头结点指针

struct hnode *next //箱子链的后继箱子指针

}hnode；

void main() {

int n，i，box_count，box_volume，*a；

hnode *box_h，*box_t，*j；

ele *p，*q；

printf(“输入箱子容积\n”)；scanf(“%d”，&box_volume)；

printf(“输入物品种数\n”)；scanf(“%d”，&n)；

a=(int )malloc(sizeof(int)*n)；//存储物品体积信息的数组

printf(“请按体积从大到小顺序输入各物品的体积：”)；

for(i=1；i<=n；i++) scanf(“%d”，a[i])；

box_h = box_t = null；//预置已用箱子链为空。

//box_h 指向已用箱子链的第一个结点，

//box_t则指向已用箱子链的最后一个结点。

box_count = 0； //预置已用箱子计数器box_count 为0 for(i=1；i<=n ；i++) { //物品i 按以下步骤装箱。

//从第一只箱子开始顺序寻找能放入物品i 的箱子j

p=(ele *)malloc(sizeof(ele))； //生成一个物品结点存放物品i p→vno=i ；

for(j=box_h ；j!=null ；j=j→next) //j 是已经放了某些物品的箱子号。

if( ① ) break ； //找还可装物品i 的箱子j

if(j==null) { //所有已用的箱子中都不能放物品i

j=( hnode *)malloc(sizeof(hnode))； //生成一个新的箱子结点j j→remainder= ② ； //修改箱子j 的剩余容量 j→head=null ；j→next = null ；

if(box_h==null) box_h = box_t = j ； //尚没有已经使用的箱子 else ③ ； //将箱子j 加入到已用箱子链中 box_count++； } else

④ ； //将物品i 放入箱子j

for(q=j→head ；q!=null && q→link!=null ；q=q→link)； if(q==null) { //新启用的箱子

p→link=j→head ；j→head=p ；} //p 结点是箱子结点j 中的第一个物品结点 else

{p→link=null ；q→link=p ；} //将p 结点插入到箱子结点j 的物品链中的最后

}//for

//输出使用的箱子数及每个箱子中的全部物品与剩余容量 printf(“共使用%d 只箱子。”，box_count)； printf(“各箱子装物品情况如下：”)；

for(j=box_h ，i=1；j!=null ；j=j→next ，i++) { //第i 只箱子情况

printf(“第%2d 只箱子，还剩余容积%4d ，所装物品有:\n”，i ，j→remainder)； for(p=j→head ；p!=null ；p=p→link)

prin tf(“%4d”，p→vno)； //输出物品的编号 printf(“\n”)； } }

所确定的数据结构如下:

20.用回溯法求8-皇后问题的算法描述如下：

{ n=8；

m=0； //从空配置开始

good=1； //空配置中皇后不相互捕捉

do{ //循环找解

if(good)

if(m==n) { //找到了一个解

输出解；

回溯，改变上一个m的选值，形成下一个候选解；

}

else 扩展当前候选解至下一列，修改m的值；

else回溯，改变上一个m的选值，形成下一个候选解；

good = 检查当前候选解的合理性；

}while(m!＝0)；

}

为了程序实现方便，约定第i行上的皇后的编号为i(1≤i≤8)。可以引入一个一维数组col[]作为该问题的数据结构。col[j]表示在棋盘第j列、col[j]行上有一个皇后，该皇后也确定了两条斜线上有皇后。为了使程序在找到全部解后能够回溯到最初位置，设定col[0]=0。当回溯到第0列时，说明程序已经求得全部解或无解，结束程序的执行。为了使程序在检查皇后配置的合理性方面简易方便，引入以下三个工作数组：数组a[]，a[k]表示第k行上还没有皇后；

数组b[]，b[t]表示第k条右高左低的斜线上没有皇后，k=行号+列号，且同一右高左低的斜线上的方格，它们的行号与列号之和均相同；

数组c[]，c[t]表示第k条左高右低的斜线上没有皇后，k=n+列号-行号，且同一左高右低的斜线上的方格，它们的行号与列号之差均相同。

初始时，所有的行和斜线上均没有皇后，从第1列的第1行开始配置第1个皇后。假设已经在第m列、col[m]行上放置了一个合理的皇后，即在数组a[]，b[]，c[]中为第m 列、col[m]行的位置设定有皇后标志。下一步准备考察在第m+1列放置皇后。当从第m 列回溯到m-1列(为该列重新配置皇后)时，应清除数组a[]，b[]，c[]中已经设置的关于第m-1列、第col[m-1]行有皇后的标志。一个皇后在m列，col[m]行的方格内的配置是合理的，等价于数组a[]，b[]，c[]中的对应分量都为1。详细程序如下，请在划线的空白处填入适当的语句以完成该程序。

#include

#include

#define maxn 8

int n，m，good；

int col[maxn+1]，a[maxn+1]；

int b[2*maxn+1]，c[2*maxn+1]；

void main() {

int j；char awn；

int n=8；

for(j=0；j<=n；j++) a[j]=1；//初始化数组a

for(j=0；j<=2*n；j++) b[j]=c[j]=1；//初始化数组b和c m=l；col[1]=1；ok=1；col[0]=0；

while(m!=0) { //循环找解

if(good)

if( ①) { //找到一个解

printf(“列\t行”)；

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

printf(“%3d\t%d\n”，j，col[j])；

printf(“Enter a character(Q/q for exit)!\n”)；

scanf(“%c”，&awn)；

if(awn==?Q?||awn==?q?) exit(0)；

while(col[m]==n) { //当最后一行已经合理地配置了皇后时，

//改变上1列的配置，求更多的解

m--；//回溯

②；//清除关于第m列，第col[m]行的有皇后标志

}//while

col[m]++；//调整第m列的皇后配置，在当前行的下1行上配置皇后

}

else { //在第m列，col[m]行位置设定有皇后标志

a[ col[m] ] = b[ m+col[m] ] = c [n+m-col[m] ] = 0；

col[++m]=1；} //尝试第m+1列，从第1行开始配置else { //配置没有成功，回溯调整

while(col[m]==n)){ //回溯

m--；

②；//清除关于第m列，第col[m]行的有皇后标志。

}

col[m]++；//调整第m列的皇后配置，在当前行的下1行上配置皇后}

good = a[ col[m] ] && ③&& ④；

}//while

}

21.找出从自然数1，2，…，n中任取r个数的所有组合。

例如n=5，r=3，所有组合为：

1 2 3

1 2 4

1 2 5

1 3 4

1 3 5

1 4 5

2 3 4

2 3 5

2 4 5

3 4 5

采用回溯法找问题的解，将找到的组合以从小到大顺序存于a[0]，a[1]，…，a[r-1]中，组合的元素满足以下性质：

(1)a[i+1]>a[i]，即后一个数字比前数字一个大；

(2)a[i]-i<=n-r+1。

按回溯算法思想，找解过程可以叙述如下：首先放弃组合数个数为r的条件，候选组合从只有一个数字1开始。因该候选解满足除问题规模之外的全部条件，扩大其规模，并使其满足上述条件(1)，候选组合改为1，2。继续这一过程，得到候选组合1，2，3。该候选解满足包括问题规模在内的全部要求，因而是一个解。在该解基础上，选下一个候选解，因a[2]上的3调整为4，以及以后再调整为5，都满足问题的全部要求，得到解1，2，4和1，2，5。由于对5不能再作调整，就要从a[2]回溯至a[1]，这时的a[1]=2，可以调整为3，并向前试探，得到解1，3，4。重复上述向前试探和向后回溯，

直至要从a[0]再回溯时，说明已找完问题的全部解。按上述思想写成程序如下：

#include

#define MAXN 100

int a[MAXN]；

void comb_back(int m，int r) {

int i，j；

i=0；a[i]=1；

do{

if( ①) { //还可以向前试探

if(i==r-l) { //已找到一个组合

fot(j=0；j

printf(“﹨n”)；

②；//找下一个组合

continue ；

}

③；//向前试探

a[i]=a[i-1]+1；

}

else { //回溯

if(i==0) return；//已找完了全部

④；//继续找下一个解

}

}while(1)；

}

void main() {

comb_back(5，3)；

}

填写空白处的语句,完成该算法。

22.马的遍历问题。在 8×8方格的棋盘上，从任意指定的方格出发，为马寻找一条走遍棋盘每一格并且只经过一次的一条路径。

马在某个方格，可以在一步内到达的不同位置最多有8个，如图9.4所示。如用二维

数组board[][]表示棋盘，其元素记录马经过该位置时的步骤号。另对马的8种可能走法(称为着法)设定一个顺序，如当前位置在棋盘的(i,j)方格，下一个可能位置依次为(i+2,j+1)，(i+1,j+2)，(i-1,j+2)，(i-2,j+1)，(i-2,j-l)，(i-1,i-2)，(i+1,j-2)，(i+2,j-l)，实际可以走的位置尽限于还未走过的和不越出棋盘边界的那些位置。为便于程序统一处理，可引人两个数组，分别存储各种可能走法对当前位置的纵横增量。

图马走一步着法示意图

用贪婪法求解该问题的方法：选择下一出口的贪婪标准是在那些允许走的位置中，选择出口最少的那个位置。如马的当前位置(i,j)只有三个出口，它们是位置(i+2,j+l)，(i-2,j+l)和(i-1,j-2)，如分别走到这些位置，这三个位置又分别会有不同的出口，假定这三个位置的出口个数分别为4，2，3，则程序就选择出口位置(i-2,j+l)。

由于程序采用的是一种贪婪法，整个找解过程是一直向前，没有回溯，所以能非常快地找到解。但是，对于某些开始位置，实际上有解，而该算法不能找到解。对于找不到解的情况，程序只要改变8种可能出口的选择顺序，就能找到解。改变出口选择顺序，就是改变有相同出口时的选择标准。以下程序考虑到这种情况，引入变量start，用于控制8种可能着法的选择顺序。开始时为0，当不能找到解时，就让start增l，重新找解。按照这种思想解8马问题的算法如下：

#include

int deltai[]=(2，1，-1，-2，-2，-l，1，2)；

int deltaj[]=(1，2，2，l，-1，-2，-2，-1)；

int board[8][8]；

int exitn( int i，int j，int s，int a[] ) {

//求(i,j)的出口数，和各出口号存于a[]中，s是顺序选择着法的开始序号

int i1，j1，k，count；

for(count=k=0 ；k<8；k++) {

i1 = i + deftai[(s+k) % 8]；

j1 = j + deftaj[(s+k) % 8]；

if(i1>=0 && i1<8 && j1>=0 && j1<8 && board[i1][j1]==0)

a[count++]=(s+k) % 8；

}//for

return count；

}//for

int next(int i，int j，int s) //选下一出口，S是顺序选择着法的开始序号

{ int m，k，kk，min，a[8]，b[8]，temp；

m = exitn(i，j，s，a)；//确定(i,j)的出口个数

if(m==0) return -1；//没有出口

for(min=9，k=0；k

temp=exitn(i+deltai[a[k]]，j+deltaj[a[k]]，s，b)；

if(temp

①；//记录最小的出口数

kk＝a[k]；

}

}

return kk；//返回选中的着法

}

void main() {

int sx，sy，i，j，step，no，start；

for(sx=0；sx<8；sx++)

for(sy=0；sy<8；sy++) {

start = 0 //从0号着法开始顺序检查

do {

for(i=0；i<8；i++)

for(j=0；j<8；j++) ②；//清棋盘

board[sx][sy]=1；

i=sx；j=sy；

for(step=2；step<=64；step++) {

if((no=③)==-1)break；//找出口不成功

i+=deftai[no]；//前进一步

j+=deftaj[no]；

board[i][j]=step；

}

if( ④) break；//找到一个解

start++；//最先检查的着法序号增1

}while(step<=64)；

for(i＝0；i<8；i++) {

for(j=0；j<8；j++)

printf(“%4d”，board[i][j])；

prlntf(“\n\n”)；

}

scanf(“%*c”)；//键人回车，找下一个起点的解

}

}

填写上述算法的空白处，完成整个算法。

23. 设有n(=2k)位选手参加网球循环赛，循环赛共进行n-1天，每位选手要与其他n-l位选手赛一场，且每位选手每天赛一场，不能轮空。试按此要求用分治法为比赛安排日程。

为了从2m-1位选手的比赛日程表，导出2m位选手的比赛日程表，假定只有8位选手(见图9.5)，若1至4号选手之间的比赛日程填在日程表的左上角(4行3列)，5至8号选手之间的比赛日程可填在日程表的左下角(4行3列)，而左下角的内容可由左上角对应项加上数4得到。至此，剩下的右上角(4行4列)是为编号小的1至4号选手与编号大的5至8号选手之间的比赛安排日程。如在第4天，让1至4号选手分别与5至8号选手比赛。以后各天，依次由前一天的日程安排，让5至8号选手循环轮转即可。最后，参照右上角得到右下角的比赛日程，如下图所示。由以上分析，不难得到为2m位选手安排比赛日程的算法思路。

依据上述算法思想编写的程序如下，试填写空白处的语句完成整个算法。 #include #define MAXN 64

int a[MAXN ＋1][MAXN ］； void main() {

int twom1,twom,i,j,m,k ；

printf(“指定n(=2的k 次幂)位选手，请输入k 。\n”，&k)； scanf(“%d”，&k)；

a[1][1]=2； //预设两位选手的比赛日程。 A[2][1]=1；

m = 1；twom1 = l ； while(m

m++；

twom1 += twom1；twom = 2*twom1； //为2m 位选手安排比赛日程。 //填日程表的左下角。

for(i=twom1 + 1；i<=twom ；i++)

for(j=l ；j<=twom1-1；j++)

① ； //填日程表的左下角

//填日程表的右上角。

a[1][twom1] = twom1 + 1； //填日程表右上角的第1列。 for(i=2；i<=twom1；i++) ② ；

//填日程表右上角的其他列，参照前一列填当前列的值 for(j=twom1+1；j

for(i=1；i

//填日程表的右下角。

for(j=twom1；j

for(i=1；i<=twom1；i++)

④ ；

//输出日程表

for(i=l ；i<=twom ；i++)｛

for(j=l ；j

printf(“\n”)； } ｝

1 2 3 4 5 6 7 1 2 3 4 5 6 7 8 2 1 4 3 6 7 8 5 3 4 1 2 7 8 5 6 4 3 2 1 8 5 6 7 5 6 7 8 1 4 3 2 6 5 8 7 2 1 4 3 7 8 5 6 3 2 1 4 8 7 6 5 4 3 2 1

? 八位选手比赛日程表

1 2 3

1 2 3 4 2 1 4 3 3 4 1 2 4 3 2 1

(b) 四位选手比赛日程表 1 1 2 2 1

(a) 两位选手比赛日程表

图 选手比赛日程安排示意图

24.完成用分治法求解使字符串s反序的的递归程序reverse(s)。

算法思路：令指针i，j分别指示字符串s的头、尾字符，然后交换i，j分别指示的字符，并修改对i指针做加1操作；对j指针做减1操作，直到i≥j。

#include

void reverse(char s[]) {

void reverser(char s[],int i,int len)；

reverser(s, ① ,strlen(s))；

}

void reverser(char s[],int i,int len) {

int c，j；

j = ②；

if (i

c = s[i]；

s[i] = s[j]；

s[j] = c；

reverser(s,++i, ③ )；

}

}

问题①的答案是？

问题②的答案是？

问题③的答案是？

以上是希望大家能够掌握的练习，考试内容不限于上述内容，但基本方法和思路是一样的，请大家掌握思想，不要死记硬背练习中的程序。