1. (3')煤球数目
有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
....
如果一共有100层，共有多少个煤球？
请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
【分析】循环+枚举
依次枚举各层，第i层煤球数=(i*(i+1))/2。
#include <stdio.h>
int main()
{
int level;
int sum=0;
for(level=1;level<=100;level++)
{
sum+=((level*(level+1))/2);
printf("%d\n",sum);
}
printf("%d\n",sum);
return 0;
}【答案】171700
2. (5')生日蜡烛
某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。
现在算起来，他一共吹熄了236根蜡烛。
请问，他从多少岁开始过生日party的？
请填写他开始过生日party的年龄数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
【分析】循环+枚举
枚举某君开始过生日的年龄数start和现在的年龄数end，用sum记录已吹熄的蜡烛数。当sum=236时，start即为解。
#include <stdio.h>
int main()
{
int start,end;
int sum;
for(start=1;start<=100;start++)
{
sum=start;
for(end=start+1;end<=100;end++)
{
sum+=end;
if(sum>236)
break;
else if(sum==236)
{
printf("start=%d end=%d\n",start,end);
break;
}
}
}
return 0;
}【答案】236
3. (11')凑算式
B DEF
A + --- + ------- = 10
C GHI
（如果显示有问题，可以参见【图1.jpg】）
这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。
比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。
这个算式一共有多少种解法？
注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。
【分析】循环+枚举
A~I代表1~9 9个数字，因此可使用全排列代替传统的9重循环枚举，并且不需手动实现去重，更加高效。
此外，B/C和DEF/GHI不一定是整数，因此在计算A+ B/C + DEF/GHI之和时，结果与10需进行实数（浮点数）的大小比较，以避免精度问题影响结果。
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
int a[9]={1,2,3,4,5,6,7,8,9};
int ans=0;
int main()
{
int i;
int n1,n2,n3,n4,n5;
double result;
do
{
n1=a[0];
n2=a[1];
n3=a[2];
n4=a[3]*100+a[4]*10+a[5];
n5=a[6]*100+a[7]*10+a[8];
result=n1+n2*1.0/n3+n4*1.0/n5;
if(fabs(result-10)<1e-8)
{
cout<<n1<<"+"<<n2<<"/"<<n3<<"+"<<n4<<"/"<<n5<<"=10"<<endl;
ans++;
}
} while(next_permutation(a,a+9));
cout<<ans<<endl;
return 0;
}4. (9')快速排序
排序在各种场合经常被用到。
快速排序是十分常用的高效率的算法。
其思想是：先选一个“标尺”，
用它把整个队列过一遍筛子，
以保证：其左边的元素都不大于它，其右边的元素都不小于它。
这样，排序问题就被分割为两个子区间。
再分别对子区间排序就可以了。
下面的代码是一种实现，请分析并填写划线部分缺少的代码。
#include <stdio.h>
void swap(int a[], int i, int j)
{
int t = a[i];
a[i] = a[j];
a[j] = t;
}
int partition(int a[], int p, int r)
{
int i = p;
int j = r + 1;
int x = a[p];
while(1){
while(i<r && a[++i]<x);
while(a[--j]>x);
if(i>=j) break;
swap(a,i,j);
}
______________________;
return j;
}
void quicksort(int a[], int p, int r)
{
if(p<r){
int q = partition(a,p,r);
quicksort(a,p,q-1);
quicksort(a,q+1,r);
}
}
int main()
{
int i;
int a[] = {5,13,6,24,2,8,19,27,6,12,1,17};
int N = 12;
quicksort(a, 0, N-1);
for(i=0; i<N; i++) printf("%d ", a[i]);
printf("\n");
return 0;
}注意：只填写缺少的内容，不要书写任何题面已有代码或说明性文字。
【分析】快速排序算法
#include <stdio.h>
void swap(int a[], int i, int j)
{
int t = a[i];
a[i] = a[j];
a[j] = t;
}
int partition(int a[], int p, int r)
{
int i = p;
int j = r + 1;
int x = a[p];
while(1){
while(i<r && a[++i]<x);
while(a[--j]>x);
if(i>=j) break;
swap(a,i,j);
}
swap(a,p,j); //填空-下标j处的数将整个序列划分为两部分
return j;
}
void quicksort(int a[], int p, int r)
{
if(p<r){
int q = partition(a,p,r);
quicksort(a,p,q-1);
quicksort(a,q+1,r);
}
}
int main()
{
int i;
int a[] = {5,13,6,24,2,8,19,27,6,12,1,17};
int N = 12;
quicksort(a, 0, N-1);
for(i=0; i<N; i++) printf("%d ", a[i]);
printf("\n");
return 0;
}【答案】swap(a,p,j)
5. (13')抽签
X星球要派出一个5人组成的观察团前往W星。
其中：
A国最多可以派出4人。
B国最多可以派出2人。
C国最多可以派出2人。
....
那么最终派往W星的观察团会有多少种国别的不同组合呢？
下面的程序解决了这个问题。
数组a[] 中既是每个国家可以派出的最多的名额。
程序执行结果为：
DEFFF
CEFFF
CDFFF
CDEFF
CCFFF
CCEFF
CCDFF
CCDEF
BEFFF
BDFFF
BDEFF
BCFFF
BCEFF
BCDFF
BCDEF
....
(以下省略，总共101行)
#include <stdio.h>
#define N 6
#define M 5
#define BUF 1024
void f(int a[], int k, int m, char b[])
{
int i,j;
if(k==N){
b[M] = 0;
if(m==0) printf("%s\n",b);
return;
}
for(i=0; i<=a[k]; i++){
for(j=0; j<i; j++) b[M-m+j] = k+'A';
______________________; //填空位置
}
}
int main()
{
int a[N] = {4,2,2,1,1,3};
char b[BUF];
f(a,0,M,b);
return 0;
}注意：不要填写任何已有内容或说明性文字。
【分析】递归/DFS
解题关键：A~F国依次派人，派人数为i(i<=a[k])
#include <stdio.h>
#define N 6
#define M 5
#define BUF 1024
int ans=0; //方案总数
//k- k+'A'国派人(A~F国依次进行) m-剩余可派出的人数
void f(int a[], int k, int m, char b[])
{
int i,j;
if(k==N){
b[M] = 0;
if(m==0){
printf("%s\n",b);
ans++;
}
return;
}
//k+'A'国派出i人
for(i=0; i<=a[k]; i++){
for(j=0; j<i; j++) b[M-m+j] = k+'A';
f(a,k+1,m-i,b); //填空位置
}
}
int main()
{
int a[N] = {4,2,2,1,1,3}; //A~F国最多可派出的人数
char b[BUF]; //派人方案
f(a,0,M,b);
printf("ans=%d\n",ans);
return 0;
}【答案】f(a,k+1,m-i,b)
6. (15')方格填数
如下的10个格子
填入0~9的数字。要求：连续的两个数字不能相邻。
（左右、上下、对角都算相邻）
一共有多少种可能的填数方案？
请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
【分析】DFS
可将给出的格子区域用一个3行4列的二维数组mat[3][4]表示，搜索填数0~9。填数完成后判断，若连续的两个数字不相邻，则方案符合要求，方案数+1。
#include <stdio.h>
#include <math.h>
#include <string.h>
int mat[3][4];
int used[10];
int dir[8][2]={{-1,-1},{-1,0},{-1,1},{0,-1},{0,1},{1,-1},{1,0},{1,1}};
int ans=0;
int Judge(int mat[][4])
{
int i,j,k;
int newx,newy;
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
{
if((i==0 && j==0) || (i==2 && j==3))
continue;
for(k=0;k<8;k++)
{
newx=i+dir[k][0];
newy=j+dir[k][1];
if(newx>=0 && newx<3 && newy>=0 && newy<4)
{
if(fabs(mat[i][j]-mat[newx][newy])==1 && mat[newx][newy]!=-1)
return 0;
}
}
}
}
return 1;
}
void dfs(int x,int y)
{
int i,j;
int num;
if(x==2 && y==3)
{
if(Judge(mat))
{
ans++;
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
printf("%d ",mat[i][j]);
printf("\n");
}
printf("\n");
}
return;
}
if(y==4)
dfs(x+1,0);
for(num=0;num<=9;num++)
{
if(!used[num])
{
used[num]=1;
mat[x][y]=num;
dfs(x,y+1);
used[num]=0;
}
}
}
int main()
{
int i,j;
memset(mat,-1,sizeof(mat));
memset(used,0,sizeof(used));
dfs(0,1);
printf("%d\n",ans);
return 0;
}【答案】1580
7. (19')剪邮票
如【图1.jpg】, 有12张连在一起的12生肖的邮票。
现在你要从中剪下5张来，要求必须是连着的。
（仅仅连接一个角不算相连）
比如，【图2.jpg】，【图3.jpg】中，粉红色所示部分就是合格的剪取。
请你计算，一共有多少种不同的剪取方法。
请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
8. (21')四平方和
四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多4个正整数的平方和。
如果把0包括进去，就正好可以表示为4个数的平方和。
比如：
5 = 0^2 + 0^2 + 1^2 + 2^2
7 = 1^2 + 1^2 + 1^2 + 2^2
（^符号表示乘方的意思）
对于一个给定的正整数，可能存在多种平方和的表示法。
要求你对4个数排序：
0 <= a <= b <= c <= d
并对所有的可能表示法按 a,b,c,d 为联合主键升序排列，最后输出第一个表示法
程序输入为一个正整数N (N<5000000)
要求输出4个非负整数，按从小到大排序，中间用空格分开
例如，输入：
5
则程序应该输出：
0 0 1 2
再例如，输入：
12
则程序应该输出：
0 2 2 2
再例如，输入：
773535
则程序应该输出：
1 1 267 838
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
【分析】枚举+暴力求解法
由题意，不难想到思路：枚举a, b, c, d（满足0 <= a <= b <= c <= d），找符合条件 a*a+b*b+c*c+d*d=N 的解即可。
但需要注意数据规模：正整数N<5000000，因此要做好充分的程序优化。
法一：由于a*a+b*b+c*c+d*d=N，故a, b, c, d每个数均不超过它们的算术平方根(也就是a*a<=N b*b<=N c*c<=N d*d<=N)。并且在求解过程中，若出现 a*a+b*b>N 或 a*a+b*b+c*c>N的情况，一定不合题意，不在继续枚举后面的数。
循环上述过程，直到找到第一组解为止。
#include <stdio.h>
#include <math.h>
int main()
{
int N,suc;
int a,b,c,d;
scanf("%d",&N);
suc=0;
for(a=0;a*a<=N;a++)
{
for(b=a;b*b<=N;b++)
{
if(a*a+b*b>N)
continue;
for(c=b;c*c<=N;c++)
{
if(a*a+b*b+c*c>N)
continue;
//不使用第四层循环，直接用求得的abc和N将d表示出来
d=sqrt(N-a*a-b*b-c*c);
//满足题意的情形
if(a*a+b*b+c*c+d*d==N)
{
printf("%d %d %d %d\n",a,b,c,d);
suc=1;
break;
}
}
if(suc==1)
break;
}
if(suc==1)
break;
}
return 0;
}法二：进一步优化
"以空间换时间"，设定一个数组get，表示i是否能够由a^2+b^2得到，1-是 0-否；
总体思路同上述法一，但效率更高。
#include <stdio.h>
#include <math.h>
#include <string.h>
#define maxn 5000010
int get[maxn]; //get[i]=1 表示i是否能够由数a^2与数b^2相加得到(1-是 0-否)
void Init(int *a,int n)
{
int i,j;
memset(a,0,sizeof(a));
for(i=0;i*i<=n;i++)
{
for(j=0;j*j<=n;j++)
{
if(i*i+j*j<=n)
a[i*i+j*j]=1;
}
}
}
int main()
{
int N,suc;
int a,b,c,d,dd;
double temp;
scanf("%d",&N);
suc=0;
Init(get,N);
for(a=0;a*a<=N;a++)
{
for(b=a;b*b<=N;b++)
{
//如果剩下的数不能由数x^2与数y^2相加得到，则不再进行后续过程
if(get[N-a*a-b*b]==0)
continue;
for(c=b+1;c*c<=N;c++)
{
//dd保存d的平方
dd=N-a*a-b*b-c*c;
//temp保存dd的算术平方根，即d
temp=sqrt(d);
//若temp为一个整数，则d=(int)temp，并输出
if(temp==(int)temp)
{
d=(int)temp;
printf("%d %d %d %d\n",a,b,c,d);
suc=1;
break;
}
}
if(suc==1)
break;
}
if(suc==1)
break;
}
return 0;
}9. (23')交换瓶子
有N个瓶子，编号 1 ~ N，放在架子上。
比如有5个瓶子：
2 1 3 5 4
要求每次拿起2个瓶子，交换它们的位置。
经过若干次后，使得瓶子的序号为：
1 2 3 4 5
对于这么简单的情况，显然，至少需要交换2次就可以复位。
如果瓶子更多呢？你可以通过编程来解决。
输入格式为两行：
第一行: 一个正整数N（N<10000）, 表示瓶子的数目
第二行：N个正整数，用空格分开，表示瓶子目前的排列情况。
输出数据为一行一个正整数，表示至少交换多少次，才能完成排序。
例如，输入：
5
3 1 2 5 4
程序应该输出：
3
再例如，输入：
5
5 4 3 2 1
程序应该输出：
2
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
【分析】贪心
自左向右遍历数组，如果当前位置i上的瓶子编号不是i，就从此位置的下一个位置开始找编号为i的瓶子（此位置记为j），然后交换a[i]与a[j] 交换次数+1即可。最终得到的结果即为最少交换次数。
#include <iostream>
#include <cstdio>
using namespace std;
const int maxn=10005;
int N,a[maxn];
int main()
{
int i,j;
int ans=0; //交换次数
scanf("%d",&N);
for(i=1;i<=N;i++)
scanf("%d",&a[i]);
//自左向右遍历
for(i=1;i<=N;i++)
{
//当前位置i上瓶子编号不是i
if(a[i]!=i)
{
//继续向右找编号为i的瓶子
for(j=i+1;j<=N;j++)
{
//j位置上瓶子编号为i，则交换a[i]与a[j]，次数+1
if(a[j]==i)
{
swap(a[i],a[j]);
ans++;
break;
}
}
}
}
printf("%d\n",ans);
return 0;
}10. (31')最大比例
X星球的某个大奖赛设了M级奖励。每个级别的奖金是一个正整数。
并且，相邻的两个级别间的比例是个固定值。
也就是说：所有级别的奖金数构成了一个等比数列。比如：
16,24,36,54
其等比值为：3/2
现在，我们随机调查了一些获奖者的奖金数。
请你据此推算可能的最大的等比值。
输入格式：
第一行为数字 N (0<N<100)，表示接下的一行包含N个正整数
第二行N个正整数Xi(Xi<1 000 000 000 000)，用空格分开。每个整数表示调查到的某人的奖金数额
要求输出：
一个形如A/B的分数，要求A、B互质。表示可能的最大比例系数
测试数据保证了输入格式正确，并且最大比例是存在的。
例如，输入：
3
1250 200 32
程序应该输出：
25/4
再例如，输入：
4
3125 32 32 200
程序应该输出：
5/2
再例如，输入：
3
549755813888 524288 2
程序应该输出：
4/1
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 3000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。
以下代码仅供参考：
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long ll;
const ll maxn=105;
ll N,x[maxn];
//各项间比值(p1-分子 p2-分母)
ll p1[maxn],p2[maxn];
//所求公比的分子与分母
ll fz,fm;
//求a与b的最大公约数
ll gcd(int a,int b)
{
if(b==0)
return a;
return gcd(b,a%b);
}
int main()
{
ll i,j;
ll cnt,g;
ll t1,t2;
double temp;
scanf("%lld",&N);
for(i=0;i<N;i++)
scanf("%lld",&x[i]);
//预处理：对x数组排序
sort(x,x+N);
//预处理：去重
cnt=1;
for(i=1;i<N;i++)
{
if(x[i]!=x[i-1])
x[cnt++]=x[i];
}
//此时N记录去重后x数组中的元素个数
N=cnt;
//如果x数组中仅剩一个数字，则公比为1/1
if(N==1)
printf("1/1\n");
//如果x数组中仅剩两个数字，则公比为两数之商
//但要注意约分:对这两个数同时除以gcd!
else if(N==2)
{
g=gcd(x[N-1],x[N-2]);
printf("%lld %lld %lld\n",x[N-1],x[N-2],g);
printf("%lld/%lld\n",x[N-1]/g,x[N-2]/g);
}
//x数组中有三个及以上数字的情况
else
{
cnt=0;
//分别求出相邻两项中后项与前项的比值，并约分
for(i=1;i<N;i++)
{
g=gcd(x[i],x[i-1]);
p1[cnt]=x[i]/g;
p2[cnt]=x[i-1]/g;
cnt++;
}
//遍历每一个比值(共cnt个)，用大的除以小的，找出最小的公比
temp=1000000000005;
for(i=0;i<cnt;i++)
{
for(j=i+1;j<cnt;j++)
{
//分子分母交叉相乘
if(p1[i]*p2[j]>p1[j]*p2[i])
{
t1=p1[i]/p1[j];
t2=p2[i]/p2[j];
}
else if(p1[i]*p2[j]<p1[j]*p2[i])
{
t1=p1[j]/p1[i];
t2=p2[j]/p2[i];
}
else if(p1[i]*p2[j]==p1[j]*p2[i])
{
t1=p1[i];
t2=p2[i];
}
if(t1*1.0/t2<temp)
{
temp=t1*1.0/t2;
fz=t1;
fm=t2;
}
}
}
//最后fz,fm即最小公比的分子与分母
g=gcd(fz,fm);
printf("%lld/%lld\n",fz/g,fm/g);
}
return 0;
}
2650
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
