C/C++语言经典、实用、趣味程序设计编程百例精解 (10)
2009-02-20 08:01
381 查看
91.人机猜数游戏
由计算机“想”一个四位数，请人猜这个四位数是多少。人输入四位数字后，计算机首先判断这四位数字中有几位是猜对了，并且在对的数字中又有几位位置也是对的，将结果显示出来，给人以提示，请人再猜，直到人猜出计算机所想的四位数是多少为止。
例如：计算机“想”了一个“1234”请人猜，可能的提示如下：
人猜的整数 计算机判断有几个数字正确 有几个位置正确
1122 2 1
3344 2 1
3312 3 0
4123 4 0
1243 4 2
1234 4 4
游戏结束
请编程实现该游戏。游戏结束时，显示人猜一个数用了几次。
*问题分析与算法设计
问题本身清楚明了。判断相同位置上的数字是否相同不需要特殊的算法。只要截取相同位置上的数字进行比较即可。但在判断几位数字正确时，则应当注意：计算机所想的是“1123”，而人所猜的是“1576”，则正确的数字只有1位。
程序中截取计算机所想的数的每位数字与人所猜的数字按位比较。若有两位数字相同，则要记信所猜中数字的位置，使该位数字只能与一位对应的数字“相同”。当截取下一位数字进行比较时，就不应再与上述位置上的数字进行比较，以避免所猜的数中的一位与对应数中多位数字“相同”的错误情况。
*程序说明与注释
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
int main()
{
int stime,a,z,t,i,c,m,g,s,j,k,l[4]; /*j:数字正确的位数 k:位置正确的位数*/
long ltime;
ltime=time(NULL); /*l:数字相同时，人所猜中数字的正确位置*/
stime=(unsigned int)ltime/2;
srand(stime);
z=random(9999); /*计算机想一个随机数*/
printf("I have a number with 4 digits in mind,please guess.\n");
for(c=1;;c++) /*c: 猜数次数计数器*/
{
printf("Enter a number with 4 digits:");
scanf("%d",&g); /*请人猜*/
a=z;j=0;k=0;l[0]=l[1]=l[2]=l[3]=0;
for(i=1;i<5;i++) /*i:原数中的第i位数。个位为第一位，千位为第4位*/
{
s=g;m=1;
for(t=1;t<5;t++) /*人所猜想的数*/
{
if(a%10==s%10) /*若第i位与人猜的第t位相同*/
{
if(m&&t!=l[0]&&t!=l[1]&&t!=l[2]&&t!=l[3])
{
j++;m=0;l[j-1]=t; /*若该位置上的数字尚未与其它数字“相同”*/
} /*记录相同数字时，该数字在所猜数字中的位置*/
if(i==t) k++; /*若位置也相同，则计数器k加1*/
}
s/=10;
}
a/=10;
}
printf("You hane correctly guessed %d digits,\n",j);
printf("and correctly guessed %d digits in exact position.\n",k);
if(k==4) break; /*若位置全部正确，则人猜对了，退出*/
}
printf("Now you have correctly guessed the whole number after %d times.\n",c);
}
Now you have correctly guessed the whole number after 7 times.
*思考题
猜数游戏。由计算机“想”一个数请人猜，人输入猜的数，如果猜对了，则结束游戏，否则计算机会给出提示，指出人猜的数是太大，还是太小。当一个数猜了20次还未猜中时，应停止猜数者继续游戏的权力，从程序中退出。
92.人机猜数游戏(2)
将以上游戏（91.人机猜数游戏）双方倒一下，请人想一个四位的整数，计算机来猜，人给计算机提示信息，最终看计算机用几次猜出一个人“想”的数。请编程实现。
*问题分析与算法设计
解决这类问题时，计算机的思考过程不可能象人一样具完备的推理能力，关键在于要将推理和判断的过程变成一种机械的过程，找出相应的规则，否则计算机难以完成推理工作。
基于对问题的分析和理解，将问题进行简化，求解分为两个步聚来完成：首先确定四位数字的组成，然后再确定四位数字的排列顺序。可以列出如下规则：
1)分别显示四个1，四个2，……，四个0，确定四位数字的组成。
2)依次产生四位数字的全部排列(依次两两交换全部数字的位置)。
3)根据人输入的正确数字及正确位置的数目，进行分别处理：
(注意此时不出现输入的情况，因为在四个数字已经确定的情况下，若有3个位置正确，则第四个数字的位置必然也是正确的)
若输入4：游戏结束。
判断本次输入与上次输入的差值
若差为2：说明前一次输入的一定为0，本次输入的为2，本次交换的两个数字的位置是正确的，只要交换另外两个没有交换过的数字即可结束游戏。
若差为-2：说明前一次输入的一定为2，本次的一定为0。说明刚交换过的两个数字的位置是错误的，只要将交换的两个数字位置还原，并交换另外两个没有交换过的数字即可结束游戏。
否则：若本次输入的正确位置数<=上次的正确位置数
则恢复上次四位数字的排列，控制转3)
否则：将本次输入的正确位置数作为“上次输入的正确位置数”，控制转3)。
*程序说明与注释
#include<stdio.h>
#include<stdlib.h>
void bhdy(int s,int b);
void prt();
int a[4],flag,count;
int main()
{
int b1,b2,i,j,k=0,p,c;
printf("Game guess your number in mind is # # # #.\n");
for(i=1;i<10&&k<4;i++) /*分别显示四个1~9确定四个数字的组成*/
{
printf("No.%d:your number may be:%d%d%d%d\n",++count,i,i,i,i);
printf("How many digits have bad correctly guessed:");
scanf("%d",&p); /*人输入包含几位数字*/
for(j=0;j<p;j++)
a[k+j]=i; /*a[]:存放已确定数字的数组*/
k+=p; /*k:已确定的数字个数*/
}
if(k<4) /*自动算出四位中包的个数*/
for(j=k;j<4;j++)
a[j]=0;
i=0;
printf("No.%d:your number may be:%d%d%d%d\n",++count,a[0],a[1],a[2],a[3]);
printf("How many are in exact positions:"); /*顺序显示四位数字*/
scanf("%d",&b1); /*人输入有几位位置是正确的*/
if(b1==4){prt();exit(0);} /*四位正确，打印结果。结束游戏*/
for(flag=1,j=0;j<3&&flag;j++) /*实现四个数字的两两(a[j],a[k]交换*/
for(k=j+1;k<4&&flag;k++)
if(a[j]!=a[k])
{
c=a[j];a[j]=a[k];a[k]=c; /*交换a[j],a[k]*/
printf("No.%d:Your number may be: %d%d%d%d\n",++count,a[0],a[1],a[2],a[3]);
printf("How many are in exact positins:");
scanf("%d",&b2); /*输入有几个位置正确*/
if(b2==4){prt();flag=0;} /*若全部正确，结束游戏*/
else if(b2-b1==2)bhdy(j,k); /*若上次与本次的差为2，则交换两个元素即可结束*/
else if(b2-b1==-2) /*若上次与本次的差为-2，则说明已交换的(a[j],a[k])是错误的
将(a[j],a[k]还原后，只要交换另外两个元素即可结束游戏*/
{
c=a[j];a[j]=a[k];a[k]=c;
bhdy(j,k);
}
else if(b2<=b1)
{
c=a[j];a[j]=a[k];a[k]=c; /*恢复交换的两个数字*/
}
else b1=b2; /*其它情况则将新输入的位置信息作为上次的位置保存*/
}
if(flag) printf("You input error!\n"); /*交换结果仍没结果，只能是人输入的信息错误*/
}
void prt() /*打印结果，结束游戏*/
{
printf("Now your number must be %d%d%d%d.\n",a[0],a[1],a[2],a[3]);
printf("Game Over\n");
}
void bhdy(int s,int b)
{
int i,c=0,d[2];
for(i=0;i<4;i++) /*查找s和b以外的两个元素下标*/
if(i!=s&&i!=b) d[c++]=i;
i=a[d[1>;a[d[1>=a[d[0>; a[d[0>=i; /*交换除a[s]和a[b]以外的两个元素*/
prt(); /*打印结果，结束游戏*/
flag=0;
}
*运行示例
假设人想的四位数是：7215
Game Begin
Now guess your number in mind is # # # #.
No.1:your number may be:1111
*问题的进一步讨论
本程序具有逻辑结构清析、算法简单正确的优点，但在接受人的输入信息时缺少必要的出错保护功能，同时在进行第三步推理过程中没有保留每次猜出的数字位置信息及人输入的回答，这样对于每次人输入的信息就无法进行合法性检查，即无法检查人的输入信息是否自相矛盾；同晨也无法充分利用前面的结果。
这些缺陷是可以改进的，但最后一个问题改进难度较大，留给大家自己去完成。
*思考题
“一条龙游戏”。在一个3×3的棋盘上，甲乙双方进行对弃，双方在棋盘上轮流放入棋子，如果一方的棋子成一直线(横、竖或斜线)，则该方赢。请编写该游戏程序实现人与机器的比赛。比赛结果有三种：输、赢或平。
在编程过程中请首先分析比赛中怎样才能获胜，找出第一步走在什么位置就最可能赢
93.汉诺塔
约19世纪末，在欧州的商店中出售一种智力玩具，在一块铜板上有三根杆，最左边的杆上自上而下、由小到大顺序串着由64个圆盘构成的塔。目的是将最左边杆上的盘全部移到右边的杆上，条件是一次只能移动一个盘，且不允许大盘放在小盘的上面。
*问题分析与算法设计
这是一个著名的问题，几乎所有的教材上都有这个问题。由于条件是一次只能移动一个盘，且不允许大盘放在小盘上面，所以64个盘的移动次数是：
18，446，744，073，709，551，615
这是一个天文数字，若每一微秒可能计算(并不输出)一次移动，那么也需要几乎一百万年。我们仅能找出问题的解决方法并解决较小N值时的汉诺塔，但很难用计算机解决64层的汉诺塔。
分析问题，找出移动盘子的正确算法。
首先考虑a杆下面的盘子而非杆上最上面的盘子，于是任务变成了：
*将上面的63个盘子移到b杆上；
*将a杆上剩下的盘子移到c杆上；
*将b杆上的全部盘子移到c杆上。
将这个过程继续下去，就是要先完成移动63个盘子、62个盘子、61个盘子….的工作。
为了更清楚地描述算法，可以定义一个函数movedisc(n,a,b,c)。该函数的功能是：将N个盘子从A杆上借助C杆移动到B杆上。这样移动N个盘子的工作就可以按照以下过程进行：
1) movedisc(n-1,a,c,b);
2) 将一个盘子从a移动到b上；
3) movedisc(n-1,c,b,a)；
重复以上过程，直到将全部的盘子移动到位时为止。
*程序说明与注释
#include<stdio.h>
void movedisc(unsigned n,char fromneedle,char toneedle,char usingneedle);
int i=0;
int main()
{
unsigned n;
printf("please enter the number of disc:");
scanf("%d",&n); /*输入N值*/
printf("\tneedle:\ta\t b\t c\n");
movedisc(n,'a','c','b'); /*从A上借助B将N个盘子移动到C上*/
printf("\t Total: %d\n",i);
}
void movedisc(unsigned n,char fromneedle,char toneedle,char usingneedle)
{
if(n>0)
{
movedisc(n-1,fromneedle,usingneedle,toneedle);
/*从fromneedle上借助toneedle将N-1个盘子移动到usingneedle上*/
++i;
switch(fromneedle) /*将fromneedle 上的一个盘子移到toneedle上*/
{
case 'a': switch(toneedle)
{
case 'b': printf("\t[%d]:\t%2d………>%2d\n",i,n,n);
break;
case 'c': printf("\t[%d]:\t%2d……………>%2d\n",i,n,n);
break;
}
break;
case 'b': switch(toneedle)
{
case 'a': printf("\t[%d]:\t%2d<……………>%2d\n",i,n,n);
break;
case 'c': printf("\t[%d]:\t %2d……..>%2d\n",i,n,n);
break;
}
break;
case 'c': switch(toneedle)
{
case 'a': printf("\t[%d]:\t%2d<…………%2d\n",i,n,n);
break;
case 'b': printf("\t[%d]:\t%2d<……..%2d\n",i,n,n);
break;
}
break;
}
movedisc(n-1,usingneedle,toneedle,fromneedle);
/*从usingneedle上借助fromneedle将N-1个盘子移动到toneedle上*/
}
}
94.兎子产子
从前有一对长寿兎子，它们每一个月生一对兎子，新生的小兎子两个月就长大了，在第二个月的月底开始生它们的下一代小兎子，这样一代一代生下去，求解兎子增长数量的数列。
*问题分析与算法设计
问题可以抽象成下列数学公式：
Un=Un-1+Un-2
其中：
n是项数(n>=3)。它就是著名的菲波那奇数列，该数列的前几为：1，1，2，3，5，8，13，21…
菲波那奇数列在程序中可以用多种方法进行处理。按照其通项递推公式利用最基本的循环控制就可以实现题目的要求。
*程序说明与注释
#include<stdio.h>
int main()
{
int n,i,un1,un2,un;
for(n=2;n<3;)
{
printf("Please enter required number of generation:");
scanf("%d",&n);
if(n<3) printf("\n Enter error!\n"); /*控制输入正确的N值*/
}
un=un2=1;
printf("The repid increase of rabbits in first %d generation is as felow:\n",n);
printf("l\tl\t");
for(i=3;i<=n;i++)
{
un1=un2;
un2=un;
un=un1+un2; /*利用通项公式求解N项的值*/
printf(i%10?"%d\t":"%d\n",un);
}
printf("\n");
}
*运行结果
Please enter required number of generation: 20
The repid increase of rabbits in first 20 generation is as felow:
1 1 2 3 5 8 13 21 34 55
89 144 233 377 610 987 1597 2584 4181 6765
95.将阿拉伯数字转换为罗马数字
将大于0小于1000的阿拉伯数字转换为罗马数字。阿拉伯数字与罗马数字的对应关系如下：
1 2 3 4 5 ……
I II III IV V ……
*问题分析与算法设计
题目中给出了阿拉伯数字与罗马数字的对应关系，题中的数字转换实际上就是查表翻译。即将整数的百、十、个位依次从整数中分解出来，查找表中相应的行后输出对应的字符。
*程序与程序设计
#include<stdio.h>
int main()
{
static char *a[][10]={"","I","II","III","IV","V","VI","VII","VIII","IX"
"","X","XX","XXX","XL","L","LX","LXX","LXXX","XCC",
"","C","CC","CCC","CD","D","DC","DCC","DCCC","CM"
}; /*建立对照表*/
int n,t,i,m;
printf("Please enter number:");
scanf("%d",&n); /*输入整数*/
printf("%d=",n);
for(m=0,i=1000;m<3;m++,i/=10)
{
t=(n%i)/(i/10); /*从高位向低位依次取各位的数字*/
printf("%s",a[2-m][t]); /*通过对照表翻译输出*/
}
printf("\n");
}
*运行结果
1. Please enter number:863
863=DCCCLXIII
2. Please enter number: 256
256=CCLVI
3. Please enter number:355
355=CCCLV
4. Please enter number:522
522=DXXII
5. Please enter number:15
15=XV
*思考题
输入正整数N，产生对应的英文数字符串并输出，例如：
1 ONE 2 TWO 3 THREE
10 TEN 11 ELEVEN
135 ONE HUNDRED THIRTY FIVE
96.选美比赛
在选美大奖赛的半决胜赛现场，有一批选手参加比赛，比赛的规则是最后得分越高，名次越低。当半决决赛结束时，要在现场按照选手的出场顺序宣布最后得分和最后名次，获得相同分数的选手具有相同的名次，名次连续编号，不用考虑同名次的选手人数。例如：
选手序号： 1，2，3，4，5，6，7
选手得分： 5，3，4，7，3，5，6
则输出名次为： 3，1，2，5，1，3，4
请编程帮助大奖赛组委会完成半决赛的评分和排名工作。
*问题分析与算法设计
问题用程序设计语言加以表达的话，即为：将数组A中的整数从小到大进行连续编号，要求不改变数组中元素的顺序，且相同的整数要具有相同的编号。
普通的排序方法均要改变数组元素原来的顺序，显然不能满足要求。为此，引入一个专门存放名次的数组，再采用通常的算法：在尚未排出名次的元素中找出最小值，并对具有相同值的元素进行处理，重复这一过程，直到全部元素排好为止。
*程序说明与注释
#include<stdio.h>
#define NUM 7 /*定义要处理的人数*/
int a[NUM+1]={0,5,3,4,7,3,5,6}; /*为简单直接定义选手的分数*/
int m[NUM+1],l[NUM+1]; /*m:已编名次的标记数组 l:记录同名次元素的下标*/
int main()
{
int i,smallest,num,k,j;
num=1; /*名次*/
for(i=1;i<=NUM;i++) /*控制扫描整个数组，每次处理一个名次*/
if(m[i]==0) /*若尚未进行名次处理(即找到第一个尚未处理的元素)*/
{
smallest=a[i]; /*取第一个未处理的元素作为当前的最小值*/
k=1; /*数组l的下标，同名次的人数*/
l[k]=i; /*记录分值为smallest的同名次元素的下标*/
for(j=i+1;j<=NUM;j++) /*从下一个元素开始对余下的元素进行处理*/
if(m[j]==0) /*若为尚未进行处理的元素*/
if(a[j]<smallest) /*分数小于当前最小值*/
{
smallest=a[j]; /*则重新设置当覵最小值*/
k=0; /*重新设置同名次人数*/
l[++k]=j; /*重新记录同名次元素下标*/
}
else if(a[j]==smallest) /*若与当前最低分相同*/
l[++k]=j; /*记录同名次的元素下标*/
for(j=1;j<=k;j++) /*对同名次的元素进行名次处理*/
m[l[j>=num;
num++; /*名次加1*/
i=0; /*控制重新开始，找下一个没排名次的元素*/
}
printf("Player-No score Rank\n");
for(j=1;j<=NUM;j++) /*控制输出*/
printf(" %3d %4d %4d\n",j,a[j],m[j]);
}
*运行结果
Player-No Score Rank
1 5 3
2 3 1
3 4 2
5 7 5
5 3 1
3 5 3
7 6 4
*思考题
若将原题中的“名次连续编号，不用考虑同名次的选手人数”，改为”根据同名次的选手人数对选手的名次进行编号“，那么应该怎样修改程序。
97.满足特异条件的数列
输入m和n(20>=m>=n>0)求出满足以下方程的正整数数列 i1,i2,…,in，使得：i1+i1+…+in=m，且i1>=i2…>=in。例如：
当n=4, m=8时，将得到如下5 个数列：
5 1 1 1 4 2 1 1 3 3 1 1 3 2 2 1 2 2 2 2
*问题分析与算法设计
可将原题抽象为：将M分解为N个整数，且N个整数的和为M，i1>= i2>=…>=in。分解整数的方法很低多，由于题目中有"i1>=i2>=…..>=in，提示我们可先确定最右边in 元素的值为1，然后按照条件使前一个元素的值一定大于等于当前元素的值，不断地向前推就可以解决问题。下面的程序允许用户选定M和N，输出满足条件的所有数列。
*程序说明与注释
#include<stdio.h>
#define NUM 10 /*允许分解的最大元素数量*/
int i[NUM]; /*记录分解出的数值的数组*/
int main()
{
int sum,n,total,k,flag,count=0;
printf("Please enter requried terms(<=10):");
scanf("%d",&n);
printf(" their sum:");
scanf("%d",&total);
sum=0; /*当前从后向前k个元素的和*/
k=n; /*从后向前正在处理的元素下标*/
i
=1; /*将最后一个元素的值置为1作为初始值*/
printf("There are following possible series:\n");
while(1)
{
if(sum+i[k]<total) /*若后k位的和小于指定的total*/
if(k<=1) /*若正要处理的是第一个元素*/
{i[1]=total-sum;flag=1;} /*则计算第一个元素的并置标记*/
else{
sum+=i[k–];
i[k]=i[k+1]; /*置第k位的值后k-1*/
continue; /*继续向前处理其它元素*/
}
else if(sum+i[k]>total||k!=1) /*若和已超过total或不是第一个元素*/
{ sum-=i[++k]; flag=0;} /*k向后回退一个元素*/
else flag=1; /*sum+i[k]=total&&k=1 则设置flag标记*/
if(flag)
{
printf("[%d]:",++count);
for(flag=1;flag<=n;++flag)
printf("%d",i[flag]);
printf("\n");
}
if(++k>n) /*k向后回退一个元素后判断是否已退出最后一个元素*/
break;
sum-=i[k];
i[k]++; /*试验下一个分解*/
}
}
*运行结果
Please enter requried terms(<=10):4
their sum:8
There are following possible series:
[1]: 5111
[2]: 4211
[3]: 3311
[4]: 3221
[5]: 2222
98.八皇后问题
在一个8×8国际象棋盘上，有8个皇后，每个皇后占一格；要求皇后间不会出现相互“攻击”的现象，即不能有两个皇后处在同一行、同一列或同一对角线上。问共有多少种不同的方法。
*问题分析与算法设计
这是一个古老的具有代表性的问题，用计算机求解时的算法也很多，这里仅介绍一种。
采用一维数组来进行处理。数组的下标i表示棋盘上的第i列，a[i]的值表示皇后在第i列所放的位置。如：a[1]=5，表示在棋盘的第一例的第五行放一个皇后。
程序中首先假定a[1]=1，表示第一个皇后放在棋盘的第一列的第一行的位置上，然后试探第二列中皇后可能的位置，找到合适的位置后，再处理后续的各列，这样通过各列的反复试探，可以最终找出皇后的全部摆放方法。
程序采用回溯法，算法的细节参看程序。
*程序说明与注释
#include<stdio.h>
#define NUM 8 /*定义数组的大小*/
int a[NUM+1];
int main()
{
int i,k,flag,not_finish=1,count=0;
i=1; /*正在处理的元素下标，表示前i-1个元素已符合要求，正在处理第i个元素*/
a[1]=1; /*为数组的第一个元素赋初值*/
printf("The possible configuration of 8 queens are:\n");
while(not_finish) /*not_finish=1:处理尚未结束*/
{
while(not_finish&&i<=NUM) /*处理尚未结束且还没处理到第NUM个元素*/
{
for(flag=1,k=1;flag&&k<i;k++) /*判断是否有多个皇后在同一行*/
if(a[k]==a[i])flag=0;
for(k=1;flag&&k<i;k++) /*判断是否有多个皇后在同一对角线*/
if((a[i]==a[k]-(k-i))||(a[i]==a[k]+(k-i))) flag=0;
if(!flag) /*若存在矛盾不满足要求，需要重新设置第i个元素*/
{
if(a[i]==a[i-1]) /*若a[i]的值已经经过一圈追上a[i-1]的值*/
{
i–; /*退回一步，重新试探处理前一个元素*/
if(i>1&&a[i]==NUM)
a[i]=1; /*当a[i]为NUM时将a[i]的值置1*/
else if(i==1&&a[i]==NUM)
not_finish=0; /*当第一位的值达到NUM时结束*/
else a[i]++; /*将a[i]的值取下一个值*/
}
else if(a[i]==NUM) a[i]=1;
else a[i]++; /*将a[i]的值取下一个值*/
}
else if(++i<=NUM)
if(a[i-1]==NUM) a[i]=1; /*若前一个元素的值为NUM则a[i]=1*/
else a[i]=a[i-1]+1; /*否则元素的值为前一个元素的下一个值*/
}
if(not_finish)
{
++count;
printf((count-1)%3?" [%2d]: ":" \n[%2d]: ",count);
for(k=1;k<=NUM;k++) /*输出结果*/
printf(" %d",a[k]);
if(a[NUM-1]<NUM) a[NUM-1]++; /*修改倒数第二位的值*/
else a[NUM-1]=1;
i=NUM-1; /*开始寻找下一个足条件的解*/
}
}
}
*思考题
一个8×8的国际象棋盘，共有64个格子。最多将五个皇后放入棋盘中，就可以控制整个的盘面，不论对方的棋子放哪一格中都会被吃掉。请编程
99.超长正整数的加法
请设计一个算法来完成两个超长正整数的加法。
*问题分析与算法设计
首先要设计一种数据结构来表示一个超长的正整数，然后才能够设计算法。
首先我们采用一个带有表头结点的环形链来表示一个非负的超大整数，如果从低位开始为每个数字编号，则第一位到第四位、第五位到第八位…的每四位组成的数字，依次放在链表的第一个、第二个、…结点中，不足4位的最高位存放在链表的最后一个结点中，表头结点的值规定为-1。例如：
大整数“587890987654321”可用如下的带表头结点head的链表表示：
按照此数据结构，可以从两个表头结点开始，顺序依次对应相加，求出所需要的进位后代入下面的运算。具体的实现算法请见程序中的注释。
*程序说明与注释
#include<stdio.h>
#include<stdlib.h>
#define HUNTHOU 10000
typedef struct node{ int data;
struct node *next;
}NODE; /*定义链表结构*/
NODE *insert_after(NODE *u,int num); /*在u结点后插入一个新的NODE，其值为num*/
NODE *addint(NODE *p,NODE *q); /*完成加法操作返回指向*p+*q结果的指针*/
void printint(NODE *s);
NODE *inputint(void);
int main()
{
NODE *s1,*s2,*s;
NODE *inputint(), *addint(), *insert_after();
printf("Enter S1= ");
s1=inputint(); /*输入被加数*/
printf("Enter S2= ");
s2=inputint(); /*输入加数*/
printf(" S1="); printint(s1); putchar('\n'); /*显示被加数*/
printf(" S2="); printint(s2); putchar('\n'); /*显示加数*/
s=addint(s1,s2); /*求和*/
printf("S1+S2="); printint(s); putchar('\n'); /*输出结果*/
}
NODE *insert_after(NODE *u,int num)
{
NODE *v;
v=(NODE *)malloc(sizeof(NODE)); /*申请一个NODE*/
v->data=num; /*赋值*/
u->next=v; /*在u结点后插入一个NODE*/
return v;
}
NODE *addint(NODE *p,NODE *q) /*完成加法操作返回指向*p+*q结果的指针*/
{
NODE *pp,*qq,*r,*s,*t;
int total,number,carry;
pp=p->next; qq=q->next;
s=(NODE *)malloc(sizeof(NODE)); /*建立存放和的链表表头*/
s->data=-1;
t=s; carry=0; /*carry:进位*/
while(pp->data!=-1&&qq->data!=-1) /*均不是表头*/
{
total=pp->data+qq->data+carry; /*对应位与前次的进位求和*/
number=total%HUNTHOU; /*求出存入链中部分的数值 */
carry=total/HUNTHOU; /*算出进位*/
t=insert_after(t,number); /*将部分和存入s向的链中*/
pp=pp->next; /*分别取后面的加数*/
qq=qq->next;
}
r=(pp->data!=-1)?pp:qq; /*取尚未自理完毕的链指针*/
while(r->data!=-1) /*处理加数中较大的数*/
{
total=r->data+carry; /*与进位相加*/
number=total%HUNTHOU; /*求出存入链中部分的数值*/
carry=total/HUNTHOU; /*算出进位*/
t=insert_after(t,number); /*将部分和存入s指向的链中*/
r=r->next; /*取后面的值*/
}
if(carry) t=insert_after(t,1); /*处理最后一次进位*/
t->next=s; /*完成和的链表*/
return s; /*返回指向和的结构指针*/
}
NODE *inputint(void) /*输入超长正整数*/
{
NODE *s,*ps,*qs;
struct number {int num;
struct number *np;
}*p,*q;
int i,j,k;
long sum;
char c;
p=NULL; /*指向输入的整数，链道为整数的最低的个位，链尾为整数的最高位*/
while((c=getchar())!='\n') /*输入整数，按字符接收数字*/
if(c>='0'&&c<='9') /*若为数字则存入*/
{
q=(struct number *)malloc(sizeof(struct number)); /*申请空间*/
q->num=c-'0'; /*存入一位整数*/
q->np=p; /*建立指针*/
p=q;
}
s=(NODE *)malloc(sizeof(NODE));
s->data=-1; /*建立表求超长正整数的链头*/
ps=s;
while(p!=NULL) /*将接收的临时数据链中的数据转换为所要求的标准形式*/
{
sum=0;i=0;k=1;
while(i<4&&p!=NULL) /*取出低四位*/
{
sum=sum+k*(p->num);
i++; p=p->np; k=k*10;
}
qs=(NODE *)malloc(sizeof(NODE)); /*申请空间*/
qs->data=sum; /*赋值，建立链表*/
ps->next=qs;
ps=qs;
}
ps->next=s;
return s;
}
void printint(NODE *s)
{
if(s->next->data!=-1) /*若不是表头，则输出*/
{
printint(s->next); /*递归输出*/
if(s->next->next->data==-1)
printf("%d",s->next->data);
else{
int i,k=HUNTHOU;
for(i=1;i<=4;i++,k/=10)
putchar('0'+s->next->data%(k)/(k/10));
}
}
}
*运行结果
*思考题
100.数字移动
在图中的九个点上,空出中间的点,其余的点上任意填入数字1到8;1的位置固定不动,然后移动其余的数字,使1到8顺时针从小到大排列.移动的规律是:只能将数字沿线移向空白的点.
请编程显示数字移动过程。
*问题分析与算法设计
分析题目中的条件,要求利用中间的空白格将数字顺时针方向排列,且排列过程中只能借空白的点来移动数字.问题的实质就是将矩阵外面的8个格看成一个环,8个数字在环内进行排序,同于受题目要求的限制"只能将数字沿线移向空白的点",所以要利用中间的空格进行排序,这样要求的排序算法与众不同.
观察中间的点,它是唯一一个与其它8个点有连线的点,即它是中心点.中心点的活动的空间最大,它可以向8个方向移动,充分利用中心点这个特性是算法设计成功与否的关键.
在找到1所在的位置后,其余各个数字的正确位置就是固定的.我们可以按照下列算法从数字2开始,一个一个地来调整各个数字的位置.
*确定数字i应处的位置;
*从数字i应处的位置开始,向后查找数字i现在的位置;
*若数字i现在位置不正确,则将数字i从现在的位置(沿连线)移向中间的空格,而将原有位置空出;依次将现有空格前的所有元素向后移动;直到将i应处的位置空出,把它移入再次空出中间的格.
从数字2开始使用以上过程,就可以完成全部数字的移动排序.
编程时要将矩阵的外边八个格看成一个环,且环的首元素是不定的,如果算法设计得不好,程序中就要花很多精力来处理环中元素的前后顺序问题.将题目中的3X3 矩阵用一个一维数组表示,中间的元素(第四号)刚好为空格,设计另一个指针数组,专门记录指针外八个格构成环时的连接关系.指针数组的每个元素依次记录环中数字在原来数组中对应的元素下标.这样通过指针数组将原来矩阵中复杂的环型关系表示成了简单的线性关系,从而大大地简化了程序设计.
*程序说明与注释
#include<stdio.h>
int a[]={0,1,2,5,8,7,6,3}; /*指针数组.依次存入矩阵中构成环的元素下标*/
int b[9]; /*表示3X3矩阵,b[4]为空格*/
int c[9]; /*确定1所在的位置后,对环进行调整的指针数组*/
int count=0; /*数字移动步数计数器*/
int main()
{
int i,j,k,t;
void print();
printf("Please enter original order of digits 1~8:");
for(i=0;i<8;i++)
scanf("%d",&b[a[i>);
/*顺序输入矩阵外边的8个数字,矩阵元素的顺序由指针数组的元素a[i]控制*/
printf("The sorting process is as felow:\n");
print();
for(t=-1,j=0;j<8&&t==-1;j++) /*确定数字1所在的位置*/
if(b[a[j>==1) t=j; /*t:记录数字1所在的位置*/
for(j=0;j<8;j++) /*调整环的指针数组,将数字1所在的位置定为环的首*/
c[j]=a[(j+t)%8];
for(i=2;i<9;i++) /*从2开始依次调整数字的位置*/
/*i:正在处理的数字,i对应在环中应当的正确位置就是i-1*/
for(j=i-1;j<8;j++) /*从i应处的正确位置开始顺序查找*/
if(b[c[j>==i&&j!=i-1) /*若i不在正确的位置*/
{
b[4]=i; /*将i移到中心的空格中*/
b[c[j>=0;print(); /*空出i原来所在的位置,输出*/
for(k=j;k!=i-1;k–) /*将空格以前到i的正确位置之间的数字依次向后移动一格*/
{
b[c[k>=b[c[k-1>; /*数字向后移动*/
b[c[k-1>=0;
print();
}
b[c[k>=i; /*将中间的数字i移入正确的位置*/
b[4]=0; /*空出中间的空格*/
print();
break;
}
else if(b[c[j>==i) break; /*数字i在正确的位置*/
}
void print(void) /*按格式要求输出矩阵*/
{
int c;
for(c=0;c<9;c++)
if(c%3==2) printf("%2d ",b[c]);
else printf("%2d",b[c]);
printf("—-%2d—-\n",count++);
}
*运行结果
*问题的进一步讨论
很显然,按照上述算法都能解决问题，但移动的步数并不是最少的。
注意算法中的两个问题。其一：数字1的位置自始自终是保持不变的；其2：没有考虑到初始情况下，位置原本就已经是正确的数字。如例中的数字5和6，按照算法，当移动其它数字时，5和6了要跟着移动多次，这显然费了不少步数。
对于实例，若让数字1参与其它数字的移动排序过程，并充分利用数字5和6初始位置已经正确这一条件，可以大大优化移动排序的过程。
*思考题
请重新设计算法，编写更优化的程序，尽可能减少移动的步数。
请设计完成两个超长正整数的减法、乘法和除法的运算。
<div align=center><script language='javascript' src='http://www.codeguru.cn/public/cnzz.js'></script></div>
由计算机“想”一个四位数，请人猜这个四位数是多少。人输入四位数字后，计算机首先判断这四位数字中有几位是猜对了，并且在对的数字中又有几位位置也是对的，将结果显示出来，给人以提示，请人再猜，直到人猜出计算机所想的四位数是多少为止。
例如：计算机“想”了一个“1234”请人猜，可能的提示如下：
人猜的整数 计算机判断有几个数字正确 有几个位置正确
1122 2 1
3344 2 1
3312 3 0
4123 4 0
1243 4 2
1234 4 4
游戏结束
请编程实现该游戏。游戏结束时，显示人猜一个数用了几次。
*问题分析与算法设计
问题本身清楚明了。判断相同位置上的数字是否相同不需要特殊的算法。只要截取相同位置上的数字进行比较即可。但在判断几位数字正确时，则应当注意：计算机所想的是“1123”，而人所猜的是“1576”，则正确的数字只有1位。
程序中截取计算机所想的数的每位数字与人所猜的数字按位比较。若有两位数字相同，则要记信所猜中数字的位置，使该位数字只能与一位对应的数字“相同”。当截取下一位数字进行比较时，就不应再与上述位置上的数字进行比较，以避免所猜的数中的一位与对应数中多位数字“相同”的错误情况。
*程序说明与注释
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
int main()
{
int stime,a,z,t,i,c,m,g,s,j,k,l[4]; /*j:数字正确的位数 k:位置正确的位数*/
long ltime;
ltime=time(NULL); /*l:数字相同时，人所猜中数字的正确位置*/
stime=(unsigned int)ltime/2;
srand(stime);
z=random(9999); /*计算机想一个随机数*/
printf("I have a number with 4 digits in mind,please guess.\n");
for(c=1;;c++) /*c: 猜数次数计数器*/
{
printf("Enter a number with 4 digits:");
scanf("%d",&g); /*请人猜*/
a=z;j=0;k=0;l[0]=l[1]=l[2]=l[3]=0;
for(i=1;i<5;i++) /*i:原数中的第i位数。个位为第一位，千位为第4位*/
{
s=g;m=1;
for(t=1;t<5;t++) /*人所猜想的数*/
{
if(a%10==s%10) /*若第i位与人猜的第t位相同*/
{
if(m&&t!=l[0]&&t!=l[1]&&t!=l[2]&&t!=l[3])
{
j++;m=0;l[j-1]=t; /*若该位置上的数字尚未与其它数字“相同”*/
} /*记录相同数字时，该数字在所猜数字中的位置*/
if(i==t) k++; /*若位置也相同，则计数器k加1*/
}
s/=10;
}
a/=10;
}
printf("You hane correctly guessed %d digits,\n",j);
printf("and correctly guessed %d digits in exact position.\n",k);
if(k==4) break; /*若位置全部正确，则人猜对了，退出*/
}
printf("Now you have correctly guessed the whole number after %d times.\n",c);
}
Now you have correctly guessed the whole number after 7 times.
*思考题
猜数游戏。由计算机“想”一个数请人猜，人输入猜的数，如果猜对了，则结束游戏，否则计算机会给出提示，指出人猜的数是太大，还是太小。当一个数猜了20次还未猜中时，应停止猜数者继续游戏的权力，从程序中退出。
92.人机猜数游戏(2)
将以上游戏（91.人机猜数游戏）双方倒一下，请人想一个四位的整数，计算机来猜，人给计算机提示信息，最终看计算机用几次猜出一个人“想”的数。请编程实现。
*问题分析与算法设计
解决这类问题时，计算机的思考过程不可能象人一样具完备的推理能力，关键在于要将推理和判断的过程变成一种机械的过程，找出相应的规则，否则计算机难以完成推理工作。
基于对问题的分析和理解，将问题进行简化，求解分为两个步聚来完成：首先确定四位数字的组成，然后再确定四位数字的排列顺序。可以列出如下规则：
1)分别显示四个1，四个2，……，四个0，确定四位数字的组成。
2)依次产生四位数字的全部排列(依次两两交换全部数字的位置)。
3)根据人输入的正确数字及正确位置的数目，进行分别处理：
(注意此时不出现输入的情况，因为在四个数字已经确定的情况下，若有3个位置正确，则第四个数字的位置必然也是正确的)
若输入4：游戏结束。
判断本次输入与上次输入的差值
若差为2：说明前一次输入的一定为0，本次输入的为2，本次交换的两个数字的位置是正确的，只要交换另外两个没有交换过的数字即可结束游戏。
若差为-2：说明前一次输入的一定为2，本次的一定为0。说明刚交换过的两个数字的位置是错误的，只要将交换的两个数字位置还原，并交换另外两个没有交换过的数字即可结束游戏。
否则：若本次输入的正确位置数<=上次的正确位置数
则恢复上次四位数字的排列，控制转3)
否则：将本次输入的正确位置数作为“上次输入的正确位置数”，控制转3)。
*程序说明与注释
#include<stdio.h>
#include<stdlib.h>
void bhdy(int s,int b);
void prt();
int a[4],flag,count;
int main()
{
int b1,b2,i,j,k=0,p,c;
printf("Game guess your number in mind is # # # #.\n");
for(i=1;i<10&&k<4;i++) /*分别显示四个1~9确定四个数字的组成*/
{
printf("No.%d:your number may be:%d%d%d%d\n",++count,i,i,i,i);
printf("How many digits have bad correctly guessed:");
scanf("%d",&p); /*人输入包含几位数字*/
for(j=0;j<p;j++)
a[k+j]=i; /*a[]:存放已确定数字的数组*/
k+=p; /*k:已确定的数字个数*/
}
if(k<4) /*自动算出四位中包的个数*/
for(j=k;j<4;j++)
a[j]=0;
i=0;
printf("No.%d:your number may be:%d%d%d%d\n",++count,a[0],a[1],a[2],a[3]);
printf("How many are in exact positions:"); /*顺序显示四位数字*/
scanf("%d",&b1); /*人输入有几位位置是正确的*/
if(b1==4){prt();exit(0);} /*四位正确，打印结果。结束游戏*/
for(flag=1,j=0;j<3&&flag;j++) /*实现四个数字的两两(a[j],a[k]交换*/
for(k=j+1;k<4&&flag;k++)
if(a[j]!=a[k])
{
c=a[j];a[j]=a[k];a[k]=c; /*交换a[j],a[k]*/
printf("No.%d:Your number may be: %d%d%d%d\n",++count,a[0],a[1],a[2],a[3]);
printf("How many are in exact positins:");
scanf("%d",&b2); /*输入有几个位置正确*/
if(b2==4){prt();flag=0;} /*若全部正确，结束游戏*/
else if(b2-b1==2)bhdy(j,k); /*若上次与本次的差为2，则交换两个元素即可结束*/
else if(b2-b1==-2) /*若上次与本次的差为-2，则说明已交换的(a[j],a[k])是错误的
将(a[j],a[k]还原后，只要交换另外两个元素即可结束游戏*/
{
c=a[j];a[j]=a[k];a[k]=c;
bhdy(j,k);
}
else if(b2<=b1)
{
c=a[j];a[j]=a[k];a[k]=c; /*恢复交换的两个数字*/
}
else b1=b2; /*其它情况则将新输入的位置信息作为上次的位置保存*/
}
if(flag) printf("You input error!\n"); /*交换结果仍没结果，只能是人输入的信息错误*/
}
void prt() /*打印结果，结束游戏*/
{
printf("Now your number must be %d%d%d%d.\n",a[0],a[1],a[2],a[3]);
printf("Game Over\n");
}
void bhdy(int s,int b)
{
int i,c=0,d[2];
for(i=0;i<4;i++) /*查找s和b以外的两个元素下标*/
if(i!=s&&i!=b) d[c++]=i;
i=a[d[1>;a[d[1>=a[d[0>; a[d[0>=i; /*交换除a[s]和a[b]以外的两个元素*/
prt(); /*打印结果，结束游戏*/
flag=0;
}
*运行示例
假设人想的四位数是：7215
Game Begin
Now guess your number in mind is # # # #.
No.1:your number may be:1111
*问题的进一步讨论
本程序具有逻辑结构清析、算法简单正确的优点，但在接受人的输入信息时缺少必要的出错保护功能，同时在进行第三步推理过程中没有保留每次猜出的数字位置信息及人输入的回答，这样对于每次人输入的信息就无法进行合法性检查，即无法检查人的输入信息是否自相矛盾；同晨也无法充分利用前面的结果。
这些缺陷是可以改进的，但最后一个问题改进难度较大，留给大家自己去完成。
*思考题
“一条龙游戏”。在一个3×3的棋盘上，甲乙双方进行对弃，双方在棋盘上轮流放入棋子，如果一方的棋子成一直线(横、竖或斜线)，则该方赢。请编写该游戏程序实现人与机器的比赛。比赛结果有三种：输、赢或平。
在编程过程中请首先分析比赛中怎样才能获胜，找出第一步走在什么位置就最可能赢
93.汉诺塔
约19世纪末，在欧州的商店中出售一种智力玩具，在一块铜板上有三根杆，最左边的杆上自上而下、由小到大顺序串着由64个圆盘构成的塔。目的是将最左边杆上的盘全部移到右边的杆上，条件是一次只能移动一个盘，且不允许大盘放在小盘的上面。
*问题分析与算法设计
这是一个著名的问题，几乎所有的教材上都有这个问题。由于条件是一次只能移动一个盘，且不允许大盘放在小盘上面，所以64个盘的移动次数是：
18，446，744，073，709，551，615
这是一个天文数字，若每一微秒可能计算(并不输出)一次移动，那么也需要几乎一百万年。我们仅能找出问题的解决方法并解决较小N值时的汉诺塔，但很难用计算机解决64层的汉诺塔。
分析问题，找出移动盘子的正确算法。
首先考虑a杆下面的盘子而非杆上最上面的盘子，于是任务变成了：
*将上面的63个盘子移到b杆上；
*将a杆上剩下的盘子移到c杆上；
*将b杆上的全部盘子移到c杆上。
将这个过程继续下去，就是要先完成移动63个盘子、62个盘子、61个盘子….的工作。
为了更清楚地描述算法，可以定义一个函数movedisc(n,a,b,c)。该函数的功能是：将N个盘子从A杆上借助C杆移动到B杆上。这样移动N个盘子的工作就可以按照以下过程进行：
1) movedisc(n-1,a,c,b);
2) 将一个盘子从a移动到b上；
3) movedisc(n-1,c,b,a)；
重复以上过程，直到将全部的盘子移动到位时为止。
*程序说明与注释
#include<stdio.h>
void movedisc(unsigned n,char fromneedle,char toneedle,char usingneedle);
int i=0;
int main()
{
unsigned n;
printf("please enter the number of disc:");
scanf("%d",&n); /*输入N值*/
printf("\tneedle:\ta\t b\t c\n");
movedisc(n,'a','c','b'); /*从A上借助B将N个盘子移动到C上*/
printf("\t Total: %d\n",i);
}
void movedisc(unsigned n,char fromneedle,char toneedle,char usingneedle)
{
if(n>0)
{
movedisc(n-1,fromneedle,usingneedle,toneedle);
/*从fromneedle上借助toneedle将N-1个盘子移动到usingneedle上*/
++i;
switch(fromneedle) /*将fromneedle 上的一个盘子移到toneedle上*/
{
case 'a': switch(toneedle)
{
case 'b': printf("\t[%d]:\t%2d………>%2d\n",i,n,n);
break;
case 'c': printf("\t[%d]:\t%2d……………>%2d\n",i,n,n);
break;
}
break;
case 'b': switch(toneedle)
{
case 'a': printf("\t[%d]:\t%2d<……………>%2d\n",i,n,n);
break;
case 'c': printf("\t[%d]:\t %2d……..>%2d\n",i,n,n);
break;
}
break;
case 'c': switch(toneedle)
{
case 'a': printf("\t[%d]:\t%2d<…………%2d\n",i,n,n);
break;
case 'b': printf("\t[%d]:\t%2d<……..%2d\n",i,n,n);
break;
}
break;
}
movedisc(n-1,usingneedle,toneedle,fromneedle);
/*从usingneedle上借助fromneedle将N-1个盘子移动到toneedle上*/
}
}
94.兎子产子
从前有一对长寿兎子，它们每一个月生一对兎子，新生的小兎子两个月就长大了，在第二个月的月底开始生它们的下一代小兎子，这样一代一代生下去，求解兎子增长数量的数列。
*问题分析与算法设计
问题可以抽象成下列数学公式：
Un=Un-1+Un-2
其中：
n是项数(n>=3)。它就是著名的菲波那奇数列，该数列的前几为：1，1，2，3，5，8，13，21…
菲波那奇数列在程序中可以用多种方法进行处理。按照其通项递推公式利用最基本的循环控制就可以实现题目的要求。
*程序说明与注释
#include<stdio.h>
int main()
{
int n,i,un1,un2,un;
for(n=2;n<3;)
{
printf("Please enter required number of generation:");
scanf("%d",&n);
if(n<3) printf("\n Enter error!\n"); /*控制输入正确的N值*/
}
un=un2=1;
printf("The repid increase of rabbits in first %d generation is as felow:\n",n);
printf("l\tl\t");
for(i=3;i<=n;i++)
{
un1=un2;
un2=un;
un=un1+un2; /*利用通项公式求解N项的值*/
printf(i%10?"%d\t":"%d\n",un);
}
printf("\n");
}
*运行结果
Please enter required number of generation: 20
The repid increase of rabbits in first 20 generation is as felow:
1 1 2 3 5 8 13 21 34 55
89 144 233 377 610 987 1597 2584 4181 6765
95.将阿拉伯数字转换为罗马数字
将大于0小于1000的阿拉伯数字转换为罗马数字。阿拉伯数字与罗马数字的对应关系如下：
1 2 3 4 5 ……
I II III IV V ……
*问题分析与算法设计
题目中给出了阿拉伯数字与罗马数字的对应关系，题中的数字转换实际上就是查表翻译。即将整数的百、十、个位依次从整数中分解出来，查找表中相应的行后输出对应的字符。
*程序与程序设计
#include<stdio.h>
int main()
{
static char *a[][10]={"","I","II","III","IV","V","VI","VII","VIII","IX"
"","X","XX","XXX","XL","L","LX","LXX","LXXX","XCC",
"","C","CC","CCC","CD","D","DC","DCC","DCCC","CM"
}; /*建立对照表*/
int n,t,i,m;
printf("Please enter number:");
scanf("%d",&n); /*输入整数*/
printf("%d=",n);
for(m=0,i=1000;m<3;m++,i/=10)
{
t=(n%i)/(i/10); /*从高位向低位依次取各位的数字*/
printf("%s",a[2-m][t]); /*通过对照表翻译输出*/
}
printf("\n");
}
*运行结果
1. Please enter number:863
863=DCCCLXIII
2. Please enter number: 256
256=CCLVI
3. Please enter number:355
355=CCCLV
4. Please enter number:522
522=DXXII
5. Please enter number:15
15=XV
*思考题
输入正整数N，产生对应的英文数字符串并输出，例如：
1 ONE 2 TWO 3 THREE
10 TEN 11 ELEVEN
135 ONE HUNDRED THIRTY FIVE
96.选美比赛
在选美大奖赛的半决胜赛现场，有一批选手参加比赛，比赛的规则是最后得分越高，名次越低。当半决决赛结束时，要在现场按照选手的出场顺序宣布最后得分和最后名次，获得相同分数的选手具有相同的名次，名次连续编号，不用考虑同名次的选手人数。例如：
选手序号： 1，2，3，4，5，6，7
选手得分： 5，3，4，7，3，5，6
则输出名次为： 3，1，2，5，1，3，4
请编程帮助大奖赛组委会完成半决赛的评分和排名工作。
*问题分析与算法设计
问题用程序设计语言加以表达的话，即为：将数组A中的整数从小到大进行连续编号，要求不改变数组中元素的顺序，且相同的整数要具有相同的编号。
普通的排序方法均要改变数组元素原来的顺序，显然不能满足要求。为此，引入一个专门存放名次的数组，再采用通常的算法：在尚未排出名次的元素中找出最小值，并对具有相同值的元素进行处理，重复这一过程，直到全部元素排好为止。
*程序说明与注释
#include<stdio.h>
#define NUM 7 /*定义要处理的人数*/
int a[NUM+1]={0,5,3,4,7,3,5,6}; /*为简单直接定义选手的分数*/
int m[NUM+1],l[NUM+1]; /*m:已编名次的标记数组 l:记录同名次元素的下标*/
int main()
{
int i,smallest,num,k,j;
num=1; /*名次*/
for(i=1;i<=NUM;i++) /*控制扫描整个数组，每次处理一个名次*/
if(m[i]==0) /*若尚未进行名次处理(即找到第一个尚未处理的元素)*/
{
smallest=a[i]; /*取第一个未处理的元素作为当前的最小值*/
k=1; /*数组l的下标，同名次的人数*/
l[k]=i; /*记录分值为smallest的同名次元素的下标*/
for(j=i+1;j<=NUM;j++) /*从下一个元素开始对余下的元素进行处理*/
if(m[j]==0) /*若为尚未进行处理的元素*/
if(a[j]<smallest) /*分数小于当前最小值*/
{
smallest=a[j]; /*则重新设置当覵最小值*/
k=0; /*重新设置同名次人数*/
l[++k]=j; /*重新记录同名次元素下标*/
}
else if(a[j]==smallest) /*若与当前最低分相同*/
l[++k]=j; /*记录同名次的元素下标*/
for(j=1;j<=k;j++) /*对同名次的元素进行名次处理*/
m[l[j>=num;
num++; /*名次加1*/
i=0; /*控制重新开始，找下一个没排名次的元素*/
}
printf("Player-No score Rank\n");
for(j=1;j<=NUM;j++) /*控制输出*/
printf(" %3d %4d %4d\n",j,a[j],m[j]);
}
*运行结果
Player-No Score Rank
1 5 3
2 3 1
3 4 2
5 7 5
5 3 1
3 5 3
7 6 4
*思考题
若将原题中的“名次连续编号，不用考虑同名次的选手人数”，改为”根据同名次的选手人数对选手的名次进行编号“，那么应该怎样修改程序。
97.满足特异条件的数列
输入m和n(20>=m>=n>0)求出满足以下方程的正整数数列 i1,i2,…,in，使得：i1+i1+…+in=m，且i1>=i2…>=in。例如：
当n=4, m=8时，将得到如下5 个数列：
5 1 1 1 4 2 1 1 3 3 1 1 3 2 2 1 2 2 2 2
*问题分析与算法设计
可将原题抽象为：将M分解为N个整数，且N个整数的和为M，i1>= i2>=…>=in。分解整数的方法很低多，由于题目中有"i1>=i2>=…..>=in，提示我们可先确定最右边in 元素的值为1，然后按照条件使前一个元素的值一定大于等于当前元素的值，不断地向前推就可以解决问题。下面的程序允许用户选定M和N，输出满足条件的所有数列。
*程序说明与注释
#include<stdio.h>
#define NUM 10 /*允许分解的最大元素数量*/
int i[NUM]; /*记录分解出的数值的数组*/
int main()
{
int sum,n,total,k,flag,count=0;
printf("Please enter requried terms(<=10):");
scanf("%d",&n);
printf(" their sum:");
scanf("%d",&total);
sum=0; /*当前从后向前k个元素的和*/
k=n; /*从后向前正在处理的元素下标*/
i
=1; /*将最后一个元素的值置为1作为初始值*/
printf("There are following possible series:\n");
while(1)
{
if(sum+i[k]<total) /*若后k位的和小于指定的total*/
if(k<=1) /*若正要处理的是第一个元素*/
{i[1]=total-sum;flag=1;} /*则计算第一个元素的并置标记*/
else{
sum+=i[k–];
i[k]=i[k+1]; /*置第k位的值后k-1*/
continue; /*继续向前处理其它元素*/
}
else if(sum+i[k]>total||k!=1) /*若和已超过total或不是第一个元素*/
{ sum-=i[++k]; flag=0;} /*k向后回退一个元素*/
else flag=1; /*sum+i[k]=total&&k=1 则设置flag标记*/
if(flag)
{
printf("[%d]:",++count);
for(flag=1;flag<=n;++flag)
printf("%d",i[flag]);
printf("\n");
}
if(++k>n) /*k向后回退一个元素后判断是否已退出最后一个元素*/
break;
sum-=i[k];
i[k]++; /*试验下一个分解*/
}
}
*运行结果
Please enter requried terms(<=10):4
their sum:8
There are following possible series:
[1]: 5111
[2]: 4211
[3]: 3311
[4]: 3221
[5]: 2222
98.八皇后问题
在一个8×8国际象棋盘上，有8个皇后，每个皇后占一格；要求皇后间不会出现相互“攻击”的现象，即不能有两个皇后处在同一行、同一列或同一对角线上。问共有多少种不同的方法。
*问题分析与算法设计
这是一个古老的具有代表性的问题，用计算机求解时的算法也很多，这里仅介绍一种。
采用一维数组来进行处理。数组的下标i表示棋盘上的第i列，a[i]的值表示皇后在第i列所放的位置。如：a[1]=5，表示在棋盘的第一例的第五行放一个皇后。
程序中首先假定a[1]=1，表示第一个皇后放在棋盘的第一列的第一行的位置上，然后试探第二列中皇后可能的位置，找到合适的位置后，再处理后续的各列，这样通过各列的反复试探，可以最终找出皇后的全部摆放方法。
程序采用回溯法，算法的细节参看程序。
*程序说明与注释
#include<stdio.h>
#define NUM 8 /*定义数组的大小*/
int a[NUM+1];
int main()
{
int i,k,flag,not_finish=1,count=0;
i=1; /*正在处理的元素下标，表示前i-1个元素已符合要求，正在处理第i个元素*/
a[1]=1; /*为数组的第一个元素赋初值*/
printf("The possible configuration of 8 queens are:\n");
while(not_finish) /*not_finish=1:处理尚未结束*/
{
while(not_finish&&i<=NUM) /*处理尚未结束且还没处理到第NUM个元素*/
{
for(flag=1,k=1;flag&&k<i;k++) /*判断是否有多个皇后在同一行*/
if(a[k]==a[i])flag=0;
for(k=1;flag&&k<i;k++) /*判断是否有多个皇后在同一对角线*/
if((a[i]==a[k]-(k-i))||(a[i]==a[k]+(k-i))) flag=0;
if(!flag) /*若存在矛盾不满足要求，需要重新设置第i个元素*/
{
if(a[i]==a[i-1]) /*若a[i]的值已经经过一圈追上a[i-1]的值*/
{
i–; /*退回一步，重新试探处理前一个元素*/
if(i>1&&a[i]==NUM)
a[i]=1; /*当a[i]为NUM时将a[i]的值置1*/
else if(i==1&&a[i]==NUM)
not_finish=0; /*当第一位的值达到NUM时结束*/
else a[i]++; /*将a[i]的值取下一个值*/
}
else if(a[i]==NUM) a[i]=1;
else a[i]++; /*将a[i]的值取下一个值*/
}
else if(++i<=NUM)
if(a[i-1]==NUM) a[i]=1; /*若前一个元素的值为NUM则a[i]=1*/
else a[i]=a[i-1]+1; /*否则元素的值为前一个元素的下一个值*/
}
if(not_finish)
{
++count;
printf((count-1)%3?" [%2d]: ":" \n[%2d]: ",count);
for(k=1;k<=NUM;k++) /*输出结果*/
printf(" %d",a[k]);
if(a[NUM-1]<NUM) a[NUM-1]++; /*修改倒数第二位的值*/
else a[NUM-1]=1;
i=NUM-1; /*开始寻找下一个足条件的解*/
}
}
}
*思考题
一个8×8的国际象棋盘，共有64个格子。最多将五个皇后放入棋盘中，就可以控制整个的盘面，不论对方的棋子放哪一格中都会被吃掉。请编程
99.超长正整数的加法
请设计一个算法来完成两个超长正整数的加法。
*问题分析与算法设计
首先要设计一种数据结构来表示一个超长的正整数，然后才能够设计算法。
首先我们采用一个带有表头结点的环形链来表示一个非负的超大整数，如果从低位开始为每个数字编号，则第一位到第四位、第五位到第八位…的每四位组成的数字，依次放在链表的第一个、第二个、…结点中，不足4位的最高位存放在链表的最后一个结点中，表头结点的值规定为-1。例如：
大整数“587890987654321”可用如下的带表头结点head的链表表示：
按照此数据结构，可以从两个表头结点开始，顺序依次对应相加，求出所需要的进位后代入下面的运算。具体的实现算法请见程序中的注释。
*程序说明与注释
#include<stdio.h>
#include<stdlib.h>
#define HUNTHOU 10000
typedef struct node{ int data;
struct node *next;
}NODE; /*定义链表结构*/
NODE *insert_after(NODE *u,int num); /*在u结点后插入一个新的NODE，其值为num*/
NODE *addint(NODE *p,NODE *q); /*完成加法操作返回指向*p+*q结果的指针*/
void printint(NODE *s);
NODE *inputint(void);
int main()
{
NODE *s1,*s2,*s;
NODE *inputint(), *addint(), *insert_after();
printf("Enter S1= ");
s1=inputint(); /*输入被加数*/
printf("Enter S2= ");
s2=inputint(); /*输入加数*/
printf(" S1="); printint(s1); putchar('\n'); /*显示被加数*/
printf(" S2="); printint(s2); putchar('\n'); /*显示加数*/
s=addint(s1,s2); /*求和*/
printf("S1+S2="); printint(s); putchar('\n'); /*输出结果*/
}
NODE *insert_after(NODE *u,int num)
{
NODE *v;
v=(NODE *)malloc(sizeof(NODE)); /*申请一个NODE*/
v->data=num; /*赋值*/
u->next=v; /*在u结点后插入一个NODE*/
return v;
}
NODE *addint(NODE *p,NODE *q) /*完成加法操作返回指向*p+*q结果的指针*/
{
NODE *pp,*qq,*r,*s,*t;
int total,number,carry;
pp=p->next; qq=q->next;
s=(NODE *)malloc(sizeof(NODE)); /*建立存放和的链表表头*/
s->data=-1;
t=s; carry=0; /*carry:进位*/
while(pp->data!=-1&&qq->data!=-1) /*均不是表头*/
{
total=pp->data+qq->data+carry; /*对应位与前次的进位求和*/
number=total%HUNTHOU; /*求出存入链中部分的数值 */
carry=total/HUNTHOU; /*算出进位*/
t=insert_after(t,number); /*将部分和存入s向的链中*/
pp=pp->next; /*分别取后面的加数*/
qq=qq->next;
}
r=(pp->data!=-1)?pp:qq; /*取尚未自理完毕的链指针*/
while(r->data!=-1) /*处理加数中较大的数*/
{
total=r->data+carry; /*与进位相加*/
number=total%HUNTHOU; /*求出存入链中部分的数值*/
carry=total/HUNTHOU; /*算出进位*/
t=insert_after(t,number); /*将部分和存入s指向的链中*/
r=r->next; /*取后面的值*/
}
if(carry) t=insert_after(t,1); /*处理最后一次进位*/
t->next=s; /*完成和的链表*/
return s; /*返回指向和的结构指针*/
}
NODE *inputint(void) /*输入超长正整数*/
{
NODE *s,*ps,*qs;
struct number {int num;
struct number *np;
}*p,*q;
int i,j,k;
long sum;
char c;
p=NULL; /*指向输入的整数，链道为整数的最低的个位，链尾为整数的最高位*/
while((c=getchar())!='\n') /*输入整数，按字符接收数字*/
if(c>='0'&&c<='9') /*若为数字则存入*/
{
q=(struct number *)malloc(sizeof(struct number)); /*申请空间*/
q->num=c-'0'; /*存入一位整数*/
q->np=p; /*建立指针*/
p=q;
}
s=(NODE *)malloc(sizeof(NODE));
s->data=-1; /*建立表求超长正整数的链头*/
ps=s;
while(p!=NULL) /*将接收的临时数据链中的数据转换为所要求的标准形式*/
{
sum=0;i=0;k=1;
while(i<4&&p!=NULL) /*取出低四位*/
{
sum=sum+k*(p->num);
i++; p=p->np; k=k*10;
}
qs=(NODE *)malloc(sizeof(NODE)); /*申请空间*/
qs->data=sum; /*赋值，建立链表*/
ps->next=qs;
ps=qs;
}
ps->next=s;
return s;
}
void printint(NODE *s)
{
if(s->next->data!=-1) /*若不是表头，则输出*/
{
printint(s->next); /*递归输出*/
if(s->next->next->data==-1)
printf("%d",s->next->data);
else{
int i,k=HUNTHOU;
for(i=1;i<=4;i++,k/=10)
putchar('0'+s->next->data%(k)/(k/10));
}
}
}
*运行结果
*思考题
100.数字移动
在图中的九个点上,空出中间的点,其余的点上任意填入数字1到8;1的位置固定不动,然后移动其余的数字,使1到8顺时针从小到大排列.移动的规律是:只能将数字沿线移向空白的点.
请编程显示数字移动过程。
*问题分析与算法设计
分析题目中的条件,要求利用中间的空白格将数字顺时针方向排列,且排列过程中只能借空白的点来移动数字.问题的实质就是将矩阵外面的8个格看成一个环,8个数字在环内进行排序,同于受题目要求的限制"只能将数字沿线移向空白的点",所以要利用中间的空格进行排序,这样要求的排序算法与众不同.
观察中间的点,它是唯一一个与其它8个点有连线的点,即它是中心点.中心点的活动的空间最大,它可以向8个方向移动,充分利用中心点这个特性是算法设计成功与否的关键.
在找到1所在的位置后,其余各个数字的正确位置就是固定的.我们可以按照下列算法从数字2开始,一个一个地来调整各个数字的位置.
*确定数字i应处的位置;
*从数字i应处的位置开始,向后查找数字i现在的位置;
*若数字i现在位置不正确,则将数字i从现在的位置(沿连线)移向中间的空格,而将原有位置空出;依次将现有空格前的所有元素向后移动;直到将i应处的位置空出,把它移入再次空出中间的格.
从数字2开始使用以上过程,就可以完成全部数字的移动排序.
编程时要将矩阵的外边八个格看成一个环,且环的首元素是不定的,如果算法设计得不好,程序中就要花很多精力来处理环中元素的前后顺序问题.将题目中的3X3 矩阵用一个一维数组表示,中间的元素(第四号)刚好为空格,设计另一个指针数组,专门记录指针外八个格构成环时的连接关系.指针数组的每个元素依次记录环中数字在原来数组中对应的元素下标.这样通过指针数组将原来矩阵中复杂的环型关系表示成了简单的线性关系,从而大大地简化了程序设计.
*程序说明与注释
#include<stdio.h>
int a[]={0,1,2,5,8,7,6,3}; /*指针数组.依次存入矩阵中构成环的元素下标*/
int b[9]; /*表示3X3矩阵,b[4]为空格*/
int c[9]; /*确定1所在的位置后,对环进行调整的指针数组*/
int count=0; /*数字移动步数计数器*/
int main()
{
int i,j,k,t;
void print();
printf("Please enter original order of digits 1~8:");
for(i=0;i<8;i++)
scanf("%d",&b[a[i>);
/*顺序输入矩阵外边的8个数字,矩阵元素的顺序由指针数组的元素a[i]控制*/
printf("The sorting process is as felow:\n");
print();
for(t=-1,j=0;j<8&&t==-1;j++) /*确定数字1所在的位置*/
if(b[a[j>==1) t=j; /*t:记录数字1所在的位置*/
for(j=0;j<8;j++) /*调整环的指针数组,将数字1所在的位置定为环的首*/
c[j]=a[(j+t)%8];
for(i=2;i<9;i++) /*从2开始依次调整数字的位置*/
/*i:正在处理的数字,i对应在环中应当的正确位置就是i-1*/
for(j=i-1;j<8;j++) /*从i应处的正确位置开始顺序查找*/
if(b[c[j>==i&&j!=i-1) /*若i不在正确的位置*/
{
b[4]=i; /*将i移到中心的空格中*/
b[c[j>=0;print(); /*空出i原来所在的位置,输出*/
for(k=j;k!=i-1;k–) /*将空格以前到i的正确位置之间的数字依次向后移动一格*/
{
b[c[k>=b[c[k-1>; /*数字向后移动*/
b[c[k-1>=0;
print();
}
b[c[k>=i; /*将中间的数字i移入正确的位置*/
b[4]=0; /*空出中间的空格*/
print();
break;
}
else if(b[c[j>==i) break; /*数字i在正确的位置*/
}
void print(void) /*按格式要求输出矩阵*/
{
int c;
for(c=0;c<9;c++)
if(c%3==2) printf("%2d ",b[c]);
else printf("%2d",b[c]);
printf("—-%2d—-\n",count++);
}
*运行结果
*问题的进一步讨论
很显然,按照上述算法都能解决问题，但移动的步数并不是最少的。
注意算法中的两个问题。其一：数字1的位置自始自终是保持不变的；其2：没有考虑到初始情况下，位置原本就已经是正确的数字。如例中的数字5和6，按照算法，当移动其它数字时，5和6了要跟着移动多次，这显然费了不少步数。
对于实例，若让数字1参与其它数字的移动排序过程，并充分利用数字5和6初始位置已经正确这一条件，可以大大优化移动排序的过程。
*思考题
请重新设计算法，编写更优化的程序，尽可能减少移动的步数。
请设计完成两个超长正整数的减法、乘法和除法的运算。
<div align=center><script language='javascript' src='http://www.codeguru.cn/public/cnzz.js'></script></div>
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- C/C++语言经典、实用、趣味程序设计编程百例精解 (10)
- C/C++语言经典、实用、趣味程序设计编程百例精解 (10)
- C/C++语言经典、实用、趣味程序设计编程百例精解（3）
- C/C++语言经典、实用、趣味程序设计编程百例精解（6）
- C/C++语言经典、实用、趣味程序设计编程百例精解（2）
- C/C++语言经典、实用、趣味程序设计编程百例精解（7）
- C/C++语言经典、实用、趣味程序设计编程百例精解（9）
- C/C++语言经典、实用、趣味程序设计编程百例精解（1）
- C/C++语言经典、实用、趣味程序设计编程百例精解（1）
- C/C++语言经典、实用、趣味程序设计编程百例精解（8）
- C/C++语言经典、实用、趣味程序设计编程百例精解（8）
- C/C++语言经典、实用、趣味程序设计编程百例精解
- C/C++语言经典、实用、趣味程序设计编程百例精解（2）
- C/C++语言经典实用趣味程序设计编程百例精解--大部分是自己写的(1)
- C/C++语言经典、实用、趣味程序设计编程百例精解（9）
- C/C++语言经典、实用、趣味程序设计编程百例精解
- C/C++语言经典、实用、趣味程序设计编程百例精解（7）
- C/C++语言经典实用趣味程序设计编程百例精解--大部分是自己写的(2)－－上
- C/C++语言经典、实用、趣味程序设计编程百例精解（2）
- C/C++语言经典、实用、趣味程序设计编程百例精解（6）