算法分析与设计程序设计题

第三章习题

5．编程打印形如以下规律的”X”方阵。

l l l 1 1 1 l 1 1 1 l

l 2 2 2 2 1 1 2 2 2 1

l 2 3 3 2 l 1 2 3 2 l

1 2 3 3 2 l l 2 2 2 1

l 2 2 2 2 1 1 l l l l 。

1 1 1 1 1 1

(1)

#include

using namespace std;

int main()

{

int i=0,j,n;

for (i=0;i<7;i++){

for (j=0;j<7;j++){

n=((abs(3-j)-abs(3-i))<=0)+(abs(3-i)<=2)+(abs(3-i)<=1 && abs(3-j)<=2)+(i==3 && abs(3-j)<=1);

printf("%d ",n);

}

printf("\n");

}

}

(2)

/* Note:Your choice is C IDE */

#include "Stdio.h"

#include "Conio.h"

int main(void)

{

int i; /*层数*/

int j; /*i 层内每边中行或列的下标*/

int m;

int a[ 100][100];

int n;/*方阵的阶*/

char ch;

start:

printf("\nPlease enter the number of row :" );

scanf("%d",&n);

/*逐层摆放数据*/

if(n%2==0)

{

for(m=0;m

for(i=m;i

for(j=m;j

{

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

}

}

else

{

for(m=0;m<(n+1)/2;m++)

for(i=m;i

for(j=m;j

{

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

}

}

for(i=0;i

{

printf("\n");/*打完一行后换行*/

printf("\n"); /*每行之间有一个空行*/

for(j=0;j

printf("%d ",a[i][j]);

}

/*可根据用户的需求打印出多个方阵*/

printf("\nPress 'Y'to continue or other to exit!\n");

ch=getche();

if(ch=='Y')

goto start;

else

return(0);

getch();

}

11．有52张牌，使它们全部正面朝上，第一轮是从第2张开始，凡是2的倍数位置上的牌翻成正面朝下；第二轮从第3张牌开始，凡是3的倍数位置上的牌，正面朝上的翻成正面朝下，正面朝下的翻成正面朝上；第三轮从第4张牌开始，凡是4的倍数位置上的牌按上面相同规则翻转，以此类推，直到翻的牌超过104张为止。统计最后有几张牌正面朝上，以及它们的位置号。

算法设计：定义有100个元素的a数组，它的每个下标变量a[i]视为一张牌，i表示其编号。a[i]=0表示第i张牌正面朝上，a[i]=1表示第i张牌正面朝下。通过算术运算a[i]=1-a[i]，模拟翻牌的操作。

算法分析：翻牌的主要操作是a[i]=1-a[i]：

第一次翻的牌是：2，4，6，8，10……

第二次翻的牌是：3，6，9，12，15……

第u次翻的牌是：u，2u，3u，4u，……

设置条件语句while(i*k<=52&&m<=104)，使语句在条件内循环执行。

问题分析：该问题与狱吏转动狱锁属同类问题。

(1)

#include

using namespace std;

void main()

{

int a[100],i,k,p=0,m=0,u=2;

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

a[i]=0;//全部正面朝上

for(i=u;i<=52;i++)//第u张牌开始

{

k=1;

while(i*k<=52&&m<=104)//i*k为牌编号

{

a[i*k]=1-a[i*k];

k++;

m++;

}

u++;

}

cout<<"The right side up cards are:"<<"\n";

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

if(a[i]==0)

{

cout<<"\t"<

p++; // 张数增加

}

cout<

cout<<"The number of right side up cards is="<

}

(2)

分析：第i次翻的是i，2i，3i，4i，……张牌，是起点为i，公差为i的等差数列。#include

using namespace std;

void main()

{

int a[100],i,k=0,p=0,m=0,u=2;

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

a[i]=0;//全部正面朝上

for(i=u;i<=52;i++)//第u张牌开始

{

for(m=0;m<=104;m++)

{ for(k=i;k<=52;k=k+i)

{ a[i]=1-a[i] } }

u++;

}

cout<<"The right side up cards are:"<<"\n";

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

if(a[i]==0)

{

cout<<"\t"<

p++; // 张数增加

}

cout<

cout<<"The number of right side up cards is="<

}

17．求这样的两个数据：五位数＝2X四位数，9个数字互不相同。

法分析：四位数的2倍是一个五位数，所以，这个五位数的范围应该在10000-20000之间，并确定这两个数值，通过N%10来拆分这两个数，并存到数组中，如果分解后的数存在就让数组加1，来判断这两个数是否符合条件，符合条件的输出打印，不符合的舍掉。

#include

using namespace std;

void judgement(int x,int y)

{

int a[10];

int m=x;

for(int i=0;i<=9;i++)//初始化

a[i]=0;

while(x)//取出每个位，并统计这个数出现的次数

{

a[x%10]++;

x/=10;

}

while(y)

{

a[y%10]++;

y/=10;

}

int sign=0;

for(i=0;i<=9;i++)//查看所有数字出现的次数。

if(a[i]>1)//查看到大于1则说明有重复的数字

{ sign=1;

break;

}

if(sign==0)

cout<<"五位数："<

}

int main()

{

for(int n=10000;n<20000;n++)

{

if(n%2==0)

judgement(n,n/2);

}

return 0;

}

第二种方法；

#include "stdafx.h"

#include

using namespace std;

//求这样的两个数:五位数=2*四位数,9个数字互不相同

int main(int argc,char* argv[])

{

int num5,num4;

for(int i=0;i<10;i++){

if (i==1){continue;}

for (int j=0;j<10;j++){

if (j==1||j==i){continue;}

for (int k=0;k<10;k++){

if (k==1||k==i||k==j){continue;}

for (int l=0;l<10;l++){

if (l==1||l==i||l==j||l==k){continue;}

for (int m=0;m<10;m++){

if (m==1||m==i||m==j||m==k||m==l){continue;}

for (int n=0;n<10;n++){

if (n==1||n==i||n==j||n==k||n==l||n==m){continue;}

for (int o=0;o<10;o++){

if (o==1||o==i||o==j||o==k||o==l||o==m||o==n){continue;}

for (int p=0;p<10;p++){

if (p==1||p==i||p==j||p==k||p==l||p==m||p==n||p==o){continue;}

num5=10000+1000*i+100*j+10*k+l;

num4=1000*m+100*n+10*o+p;

if (num5==2*num4)

{

cout<

}

}

}

}

}

}

}

}

}

return 0;

}

23．乘式还原。有乘法运算如下：

OOO

X O

OOOO

式中8个O位置上的数字全部是素数(1、3、5或7)，请还原这个算式。

#include "Stdio.h"

#include "Conio.h"

int main()

{

int i,j,k,m;

int n;

int a[] = {2, 3, 5, 7};

for(i = 0; i < 4; ++i){

for(j = 0; j < 4; ++j){

for(k = 0; k < 4; ++k){

for(m = 0; m < 4; ++m){

n = (100*a[i] + 10*a[j] + a[k]) * a[m];

if((n/1000==2)

||(n/1000==3)||(n/1000==5)||(n/1000==7))

if(((n%1000)/100 == 2) ||((n%1000)/100 == 3)

||((n%1000)/100 == 5) ||((n%1000)/100 == 7))

if((((n%1000)%100)/10 == 2) ||(((n%1000)%100)/10 == 3) ||(((n%1000)%100)/10 == 5) ||(((n%1000)%100)/10 == 7))

if((((n%1000)%100)%10 == 2) ||(((n%1000)%100)%10 == 3) ||(((n%1000)%100)%10 == 5) ||(((n%1000)%100)%10 == 7))

printf("%d*%d=%d\n",(100*a[i] + 10*a[j] +

a[k]),a[m],(100*a[i] + 10*a[j] + a[k]) * a[m]); }}}}

return 0;

}

第四章

习题

4．一个实数列共有N 项，已知：

()

60)n i (1211<<<+-=+-d a a a i i i

键盘输入N 、a n 、d 。、n ，输出a n 。

分析：

根据公式ai=(ai-1-ai+1)/2+d 变形得，ai+1=ai-1-2ai+2d ，因此该数列的通项公式为：ai=ai-2-2ai-1+2d ，已知a1，如果能求出a2，这样就可以根据公式递推求出am

∵ ai=ai-2-2ai-1+2d ……①

=ai-2-2（ai-3-2ai-2+2d ）+2d

=-2ai-3+5（ai-4-2ai-3+2d ）-2d

=5ai-4-12ai-3+8d

……

一直迭代下去，直到最后，可以建立ai 和a1与a2的关系式。

设ai=Pia2+Qid+Ria1，我们来寻求Pi,Qi,Ri 的变化规律。

∵ ai=ai-2-2ai-1+2d

∴ ai=Pi-2a2+Qi-2d+Ri-2a1-2（Pi-1a2+Qi-1d+Ri-1a1）+2d

=(Pi-2-2Pi-1)a2+(Qi-2-2Qi-1+2)d+(Ri-2-2Ri-1)a1

∴ Pi=Pi-2-2Pi-1 ……②

Qi=Qi-2-2Qi-1+2 ……③

Ri=Ri-2-2Ri-1 ……④

显然，P1=0 Q1=0 R1=1 （i=1）

P2=1 Q2=0 R2=0 （i=2）

将初值P1、Q1、R1和P2、Q2、R2代入②③④可以求出Pn 、Qn 、Rn ∵ an=Pna2+Qnd+Rna1

∴ a2=(an-Qnd+Rna1)/Pn

然后根据公式①递推求出am ，问题解决。

但仔细分析，上述算法有一个明显的缺陷：在求由于在求a2要运用除法，因此会存在实数误差，这个误差在以后递推求an 的过程又不断的扩大。在实际中，当n 超过30时，求出的an 就明显偏离正确值。显然，这种算法虽简单但不可靠。 为了减少误差，我们可设计如下算法：

∵ ai=Pia2+Qid+Ria1

=Pi-1a3+Qi-1d+Ri-1a2

=Pi-2a4+Qi-2d+Ri-2a3

……

=Pi-2+kak+Qi-2+kd+Ri-2+kak-1

∴ an=Pn-k+2ak+Qn-k+2d+Rn-k+2ak-1

ak=(an-Qn-k+2d+Rn-k+2ak-1)/Pn-k+2 ……⑤

根据公式⑤，可以顺推a2、a3、…、an 。虽然仍然存在实数误差，但由于Pn-k+2递减，因此最后得出的an 要比直接利用公式①精确得多。

程序如下：

#include

#include

int main()

{

int N = 0;

double d = 0.0;

double A[60] ={0.0};

int m = 0;

printf( "输入 N d A1 AN m:\n ");

scanf( "%d %lf ",&N,&d);

scanf( "%lf %lf %d ",&A[0],&A[N-1],&m);

for(int i=0;i <10000;i++)

{

for(int j=1;j

{

A[j] = (A[j-1]-A[j+1])/2+d;

}

} /* 输出 */

for(int k=0;k

{

printf( "A%d = %8.2lf ",k+1,A[k]);

if(k+1 == m) printf( "\t\t // !!! ");

printf( "\n ");

}

return 0;

}

10．利用分治法求一组数据的和。

在算法设计中每次一个问题分解成的子问题个数一般是固定的，每个子问题的规模也是平均分配的。

二分法当每次都将问题分解为原问题规模的一半时，称为二分法。

二分法是分治法较常用的分解策略，数据结构课程中的折半查找、归并排序等算法都是采用此策略实现的。

#include

main()

{

int a[10]={1,3,5,7,9,10,8,6,4,2};

int i,max1=0,max2=0,min1=0,min2=0;

for(i=0;i<10;i++)

{

if(a[max1]

max1=i;

if(a[min1]>a[i])

min1=i;

}

if(max1==0)

max2=1;

if(min1==0)

min2=1;

for(i=0;i<10;i++)

{

if(i==max1||i==min1)

continue;

if(a[max2]

max2=i;

if(a[min2]>a[i])

min2=i;

}

printf("max1=%d\nmax2=%d\nmin1=%d\nmin2=%d\n",a[max1],a[max2],a[min1] ,a[min2]);

}

16．N块银币中有一块不合格，已知不合格的银币比正常银币重，现用一天平，请利用它找不合格的银币，并且用天平的次数最少。

方法一：

#include

#include

using namespace std;

int main()

{

int n;

while(cin>>n)

{

if(n <= 0)

break;

int result = (int)ceil(log((double)n)/log(3.0));

cout<<"Times:"<

}

return 0;

}

方法二：

#include

#include

int main()

{ int N;

int t=0;

scanf("%d",&N);

N=N/3;

t++;

while(N)

{

N=N/3;

t++;

}

printf("%d\n",t);

system("PAUSE");

return 0;

}

方法三：

/* 在最坏情况下求使用天平的最少次数*/

#include

#include

int main()

{

int t=0,m=1;

scanf("%d",&N);

while(m

m=m*3;

t++;

}

printf("%d\n",t);

system("PAUSE");

return 0;

}

2 求3个数的最小公倍数

算法1分析：

最小公倍数的定义以及用短除法求这3个数的最小公倍数，甚至想到了最大公约数与最小公倍数的换算公式……。其实，与问题相关的每一个经验和思路，都可能是解决这个问题的一种方法，下面就给出用这4种思路进行算法设计的过程。

给出三个数x,y,z,求这三个数的最小公倍数c，其中c是每一个数的倍数，且是他们三个

的最小的公倍数

3个数据最小公倍数的定义为“3个数的公倍数中最小的一个”。直接用最小公倍数的定义进行算法设计，其实就是用蛮力法进行算法设计。按定义将其中一个数逐步从小到大扩大1，2，3，4，5，……自然数的倍数，直到它的某一倍数正好也是其他两个数据的倍数，也就是说，能被其他两个数据整除，这就找到了问题的解。

为了提高求解的效率，先选出3个数的最大值，然后对这个最大值从1开始，扩大自然数的倍数，直到这个积能被全部3个数整除为止，这个积就是它们的最小公倍数了。

Least_common_multiplel()

{

Int x1,x2,x3,x0;

Print("input 3 number:");

Input(x1,x2,x3);

x0=max(x1,x2,x3);

i=1;

While(1)

{

j=x0*i;

if(j mod x1=0 and j mod x2=0 and j mod x3=0) break;

i=i+1;

}

print(x1,x2,x3,"Least_common_multiplel is",j);

} max(int x,int y,int z)

{

if(x>y and x>z)return(x);

else if(y>x and y>z)return(y);

else return(z);

}}

n

F(n)=∑1=n

i=1

按照算法设计1，只需一重循环就能解决问题

算法的时间复杂性为O（n）。

算法2分析：

先看求解两个数最小公倍数的方法。记两个正整数a、b的最小公倍数是d,最大公约数为c。则最小公倍数d=a*b/c。

则求解三个数的最小公倍数方法为：先求两个数x、y的最小公倍数，记为s，再求s、z的最小公倍数，这样就求出3个数的最小公倍数了。

#include

void main()

{

int n1,n2,n3;

int a,b,c;

cin>>n1>>n2>>n3;

a = n1;

b = n2;

c = n3;

while(a!=b)

/*利用展转相加法求出n1,n2

的最小公倍数，存a,b中*/

{

if (a < b)

a+=n1;

else

b+=n2;

}

while(a!=c)

/*利用展转相加法求出a,n3的最小公倍数，存a,c中*/

{ if(a < c)

a+=b;

else

c+=n3;

} cout<

}

j

F(n)=∑1=j

i=1

按照算法设计2，只需一重循环就能解决问题

算法的时间复杂性为O（n）。

函数least_common_multiple()的功能就是求几个数的最小公倍数，使用辗转相乘法实现的。

算法3设计：

1）用短除法求三个已知数的最小公倍数的过程就是求它们的因数之积，这个因数可能是三个数共有的、两个数共有或一个数独有的三种情况。

2）在手工完成这个问题时，我们的大脑可以判断三个数含有哪些因数，及属于哪种情况。用算法实现就只能利用尝试法了。尝试的范围应该是2——三个数中最大数之间的因数。

3）再看例子2，4，8中2是的因数，为避免因数重复计算，一定要用2整除这三个数得到1，2，4。注意到2仍是（1，2，4）的因数，所以在尝试某数是否是三个数的因数时，不是用条件语句if，而是要用循环语句while，以保证将三个数中所含的某个因数能全部被找出，直到三个数都不含这个数做因数时循环结束。

4）由于某数i是已知三个数的因数有多种情况，以上讨论了三大类，后两类又能细分出更小的类别，如果是其中的两个数共有的因数时，可能是第一、第三个数的因数，或是第一、第二数的因数，或是第二个、第三个数的因数。总之，很难用一个简单的逻辑表达式来表示各种复杂的情况。

用表达式：K=(x1 mod i=0)+ (x2 mod i=0)+ (x3 mod i=0)的值，可以区分某数i是否为已知3个数的因数，k=0表示i不是3个数的因数，k>0表示i是3个数的因数。

为避免因数重复计算，每次都需要除掉3个整数中已找到的因数。而以上逻辑表达式无

法识别i具体是哪一个数的因数，要对那个数进行整除i的运算。

main( )

{ int x1,x2,x3,t=1,i,flag,x0;

print(“Input 3 number:”); input(x1,x2,x3);

x0=max(x1,x2,x3);

for (i=2;i<=x0;i=i+1)

{flag=1;

while(flag=1)

{ flag=0;

if (x1 mod i=0) {x1=x1/i; flag=1;}

if(x2 mod i=0) {x2=x2/i; flag=1;}

if(x3 mod i=0) {x3=x3/i; flag=1;}

if (flag=1) t=t*i; }//while结束符

x0=max(x1,x2,x3) }//for结束符

print(“The result is ”,t);

}

在while循环体外将flag置为1，是为了能进入循环。一进入循环马上将其置为0，表示假设i不是3个数的因数，以下用3个条件语句测试；发现i是某个数的因数，则用因数去除对应整数，并将flag置为1，表示i某数的因数；循环体最后测试flag的值，若为1则累乘i因数；否则，i不是任意一个数的因数。

通过以上算法设计过程应该看到，可以依赖以前学到的解决问题方法，改进有关步骤以便能通过机械的计算机操作（准确地说是通过程序设计语言）来实现。