第七届蓝桥杯个人赛省赛--C语言B组

题目一

煤球数目

有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
....
如果一共有100层，共有多少个煤球？

请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

答案：

解析：

方法一：数学方法

方法二：暴力循环

易知每一层的数目都是上一层煤球数加上这一层的层数，代码如下：

 #include<cstdio>
 #include<iostream>
 using namespace std;

 int main()
 {
     int i=,sum=,num=;
     //sum是煤球总数，num是当前层煤球数
     for(i=;i<=;i++)
     {
         num+=i;
         sum+=num;
     }
     printf("%d\n",sum);
     return ;
 }

题目二

生日蜡烛

某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。

现在算起来，他一共吹熄了236根蜡烛。

请问，他从多少岁开始过生日party的？

请填写他开始过生日party的年龄数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

答案：26

解析：

暴力枚举，代码如下：

 #include<cstdio>
 #include<iostream>
 using namespace std;

 int main()
 {
     int i,j,num;
     //设某君从i岁开始过生日，现在j岁
     //num是吹灭掉蜡烛数
     for(i=;i<;i++)
     {
         for(j=;j<;j++)
         {
             num=(i+j)*(j-i+)/;
             if(num==)
             {
                 printf("%d\n",i);
                 break;
             }
         }
     }
     return ;
 }

题目三

凑算式

这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。

比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。

这个算式一共有多少种解法？

注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。

答案：29

解析：

方法一：递归法/DFS法，请自行百度

方法二：暴力枚举，注意每个字母代表的数字都不一样。代码如下：

 #include<cstdio>
 #include<iostream>
 using namespace std;

 int main()
 {
     int a[];//a[0]~a[8]代表A-I
     int sum=;
     double num=;
     for(a[]=;a[]<=;a[]++)
     {
         for(a[]=;a[]<=;a[]++)
         {
             if(a[]==a[])
                 continue;
             for(a[]=;a[]<=;a[]++)
             {
                 if(a[]==a[]||a[]==a[])
                     continue;
                 for(a[]=;a[]<=;a[]++)
                 {
                     if(a[]==a[]||a[]==a[]||a[]==a[])
                         continue;
                     for(a[]=;a[]<=;a[]++)
                     {
                         if(a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[])
                             continue;
                         for(a[]=;a[]<=;a[]++)
                         {
                             if(a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[])
                                 continue;
                             for(a[]=;a[]<=;a[]++)
                             {
                                 if(a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[])
                                     continue;
                                 for(a[]=;a[]<=;a[]++)
                                 {
                                     if(a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[])
                                         continue;
                                     for(a[]=;a[]<=;a[]++)
                                     {
                                         if(a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[]||a[]==a[])
                                             continue;
                                         num=(double)a[]+(double)a[]/a[]+(double)(a[]*+a[]*+a[])/(a[]*+a[]*+a[]);
                                         if(num==10.0)
                                         {
                                             sum++;
                                         }
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
     printf("%d\n",sum);
     return ;
 }

题目四

快速排序

排序在各种场合经常被用到。
快速排序是十分常用的高效率的算法。

其思想是：先选一个“标尺”，
用它把整个队列过一遍筛子，
以保证：其左边的元素都不大于它，其右边的元素都不小于它。

这样，排序问题就被分割为两个子区间。
再分别对子区间排序就可以了。

下面的代码是一种实现，请分析并填写划线部分缺少的代码。

 #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 + ;
     int x = a[p];
     while(){
         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-);
         quicksort(a,q+,r);
     }
 }

 int main()
 {
     int i;
     int a[] = {,,,,,,,,,,,};
     int N = ;

     quicksort(a, , N-);

     for(i=; i<N; i++) printf("%d ", a[i]);
     printf("\n");

     return ;
 }

注意：只填写缺少的内容，不要书写任何题面已有代码或说明性文字。

答案：swap(a,p,j)

可验证的完整代码如下：

 #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 + ;
     int x = a[p];
     while(){
         while(i<r && a[++i]<x);
         while(a[--j]>x);
         if(i>=j) break;
         swap(a,i,j);
     }
     //______________________;
     swap(a,p,j);
     return j;
 }

 void quicksort(int a[], int p, int r)
 {
     if(p<r){
         int q = partition(a,p,r);
         quicksort(a,p,q-);
         quicksort(a,q+,r);
     }
 }

 int main()
 {
     int i;
     int a[] = {,,,,,,,,,,,};
     int N = ;

     quicksort(a, , N-);

     for(i=; i<N; i++) printf("%d ", a[i]);
     printf("\n");

     return ;
 }

题目五

抽签

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] = ;
         if(m==) printf("%s\n",b);
         return;
     }

     for(i=; i<=a[k]; i++){
         for(j=; j<i; j++) b[M-m+j] = k+'A';
         ______________________;  //填空位置
     }
 }
 int main()
 {
     int  a[N] = {,,,,,};
     char b[BUF];
     f(a,,M,b);
     return ;
 }

仔细阅读代码，填写划线部分缺少的内容。

注意：不要填写任何已有内容或说明性文字。

答案：f(a,k+1,m-i,b)  或者 f(a,k+1,m-j,b)

代码填空题完成后代入完整程序进行验证是最好的检验方法。

可验证的完整代码如下：

 #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] = ;
         if(m==) printf("%s\n",b);
         return;
     }

     for(i=; i<=a[k]; i++){
         for(j=; j<i; j++) b[M-m+j] = k+'A';
         f(a,k+,m-i,b) ;  //填空位置
     }
 }
 int main()
 {
     int  a[N] = {,,,,,};
     char b[BUF];
     f(a,,M,b);
     return ;
 }

题目六

方格填数

如下的10个格子

填入0~9的数字。要求：连续的两个数字不能相邻。
（左右、上下、对角都算相邻）

一共有多少种可能的填数方案？

请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

答案：1580

解析：http://www.cnblogs.com/xiangguoguo/p/5339605.html

 #include<stdio.h>
 #include<stdlib.h>
 int count=;
 int take[],index=;//记录当前已经填入的数字，用于填数字前判断是否已经使用，避免重复使用
 int is_legal(int s[][])//判断是否满足要求：相邻位置数字不能相邻，就是两数字的差大于1.就是为什么s[0][0]、s[2][3]置为-2；
 {
     //这里的判断方法有点死板。假设每个位置都有上下左右和对角，只需要判断这些位置
     //是不是在数组中，在就进行比较，不在就说明没有。
     for(int i=;i<;i++)
     {
         for(int j=;j<;j++)
         {
             if(j->=)
             {
                 if(abs(s[i][j]-s[i][j-])==)
                 {
                     return ;
                 }
             }
             if(j+<)
             {
                 if(abs(s[i][j]-s[i][j+])==)
                 {
                     return ;
                 }
             }
             if(i+<)
             {
                 if(abs(s[i][j]-s[i+][j])==)
                 {
                     return ;
                 }
             }
             if(j->=&&i+<)
             {
                 if(abs(s[i][j]-s[i+][j-])==)
                 {
                     return ;
                 }
             }
             if(j+<&&i+<)
             {
                 if(abs(s[i][j]-s[i+][j+])==)
                 {
                     return ;
                 }
             }
             if(i->=&&j+<)
             {
                 if(abs(s[i][j]-s[i-][j+])==)
                 {
                     return ;
                 }
             }
             if(i->=)
             {
                 if(abs(s[i][j]-s[i-][j])==)
                 {
                     return ;
                 }
             }
             if(j->=&&i->=)
             {
                 if(abs(s[i][j]-s[i-][j-])==)
                 {
                     return ;
                 }
             }
         }
     }
     return ;
 }
 void fun(int s[][],int a,int b)
 {
     int i;
     if(a==&&b==)//表示当前已经填满了表格，需要进行判断看是否满足要求
     {
         if(is_legal(s))
         {
             count++;
         }
     }
     else//继续填写
     {
         for(i=;i<=;i++)
         {
             int j;
             for(j=;j<index;j++)//填写的数字必须是没有用过的
             {
                 if(i==take[j])
                 {
                     break;
                 }
             }
             if(j==index)
             {
                 s[a][b]=i;
                 take[index++]=i;
                 if(b<)//表示当前行还没填完
                 {
                     fun(s,a,b+);
                 }
                 else//当前行填完就从下一行开始
                 {
                     if(a<)//判断当前行是否是最后一行
                     {
                         fun(s,a+,);
                     }
                 }
                 index--;//在一次填满结束后，当前位置的数字换为其他可以填写的数字
                         //所以当前使用的数字需要出去。
             }
         }
     }
 }
 int main()
 {
     int s[][];
     s[][]=-;
     s[][]=-;
     //左上角和右下角没有，为了方便判断把数值设为-2（小于-1大于10均可）
     fun(s,,);
     printf("%d\n",count);
     return ;
 }

 题目七

剪邮票

如【图1.jpg】, 有12张连在一起的12生肖的邮票。
现在你要从中剪下5张来，要求必须是连着的。
（仅仅连接一个角不算相连）
比如，【图2.jpg】，【图3.jpg】中，粉红色所示部分就是合格的剪取。

请你计算，一共有多少种不同的剪取方法。

请填写表示方案数目的整数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

答案：116

解析：http://www.cnblogs.com/program-ccc/p/5321243.html

 #include<cstdio>
 #include<cstring>
 using namespace std;
 int a[][]={
     {,,,},
     {,,,},
     {,,,}};//为了方便，均执行-1操作
 int vec[];
 int res;
 int dx[]={,,-,};
 int dy[]={,,,-};
 int vis[][];
 bool Include(int x)
 {
     for(int i=;i<;i++)
         if(vec[i]==x)    return true;
     return false;
 }
 void Connect(int y,int x)
 {
     for(int i=;i<;i++)
     {
         int ny=dy[i]+y;
         int nx=dx[i]+x;
         if(<=ny&&ny<&&<=nx&&nx<&&!vis[ny][nx]&&Include(a[ny][nx]))
         {
                 vis[ny][nx]=;
                 Connect(ny,nx);
         }
     }
 }
 void dfs(int i,int j)
 {
     if(i==)
     {
         if(j==)
         {
             memset(vis,,sizeof(vis));
             int y=vec[]/,x=vec[]%;
             vis[y][x]=;
             Connect(y,x);
             int mark=;
             for(int k=;k<j;k++)
             {
                 y=vec[k]/;
                 x=vec[k]%;
                 if(vis[y][x]==)
                     mark++;
             }
             if(mark==)    res++;
         }
         return ;
     }
     vec[j]=*(a[]+i);
     dfs(i+,j+);
     vec[j]=;
     dfs(i+,j);
 }

 int main()
 {
     res=;
     dfs(,);
     printf("%d\n",res);
     return ;
 }

  题目八

四平方和

四平方和定理，又称为拉格朗日定理：
每个正整数都可以表示为至多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>， 不能通过工程设置而省略常用头文件。

提交时，注意选择所期望的编译器类型。

解析：http://blog.csdn.net/luoluozlb/article/details/51339287

 #include <stdio.h>
 #include <math.h>

 int main()
 {
     int a, b, c, n, flag = ;
     double maxN, d;
     scanf("%d", &n);
     maxN = sqrt((double)n);

     for(a = ; a <= maxN; a ++){
         for(b = a; b <= maxN; b ++){
             for(c = b; c <= maxN; c ++){
                 d = sqrt((double)(n - a*a - b*b - c*c));
                 if(d == (int)d){
                     printf("%d %d %d %d\n", a, b, c, (int)d);
                     flag = ;
                     break;
                 }
             }
             if(flag)
                 break;
         }
         if(flag)
             break;
     }
     return ;
 }

题目九

交换瓶子

有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>， 不能通过工程设置而省略常用头文件。

提交时，注意选择所期望的编译器类型。

解析：http://blog.csdn.net/luoluozlb/article/details/51339307

 #include <stdio.h>
 #include <math.h>

 int main()
 {
     int arr[];        //记录第i个瓶子编号为多少
     int flag[];    //记录编号为i的瓶子在哪儿
     int ans = ;
     int n,i;
     scanf("%d",&n);

     for(i =  ; i <= n ; i ++)
         scanf("%d",&arr[i]);

     for(i =  ; i <= n ; i ++ )
         flag[arr[i]] = i;

     for(i =  ; i <= n ; i ++)
     {
         if( i != arr[i] )
         {
             int x = arr[i];
             arr[i] ^= arr[flag[i]] ^= arr[i] ^= arr[flag[i]];
             flag[i] ^= flag[x] ^= flag[i] ^= flag[x];
             ans ++;
         }
     }

     printf("%d\n",ans);
     return ;
 }

题目十

最大比例

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>， 不能通过工程设置而省略常用头文件。

提交时，注意选择所期望的编译器类型。

解析：http://www.aichengxu.com/cyvyan/6607933.htm

 #include <iostream>
 #include <algorithm>
 #include <cstring>
 using namespace std;

 long long int a[],p1[],p2[];

 long long int gcd(long long int a,long long int b)
 {
     long long int t;
     while(t=a%b)
     {
         a=b;
         b=t;
     }
     return b;
 }

 int main()
 {
     int n;
     cin>>n;

     memset(a,,sizeof(a));
     for(int i=; i<n; i++)
     {
         cin>>a[i];
     }
     sort(a,a+n);//从小到大排序
     int k=;
     for(int i=; i<n; i++)//去掉重复的数字
     {
         if(a[i]!=a[i-])
             a[k++]=a[i];
     }
     n=k;
     if(n==)//如果只剩下一个数字，则公比为1/1
     {
         cout<<"1/1"<<endl;
         return ;
     }
     else if(n==)//如果剩下两个数字，则公比为两者的商，利用最大公约数求商
     {
         long long int g=gcd(a[n-],a[n-]);
         cout<<a[n-]/g<<"/"<<a[n-]/g<<endl;
     }
     else if(n>)
     {
         k=;
         long long int g,g1,g2;
         for(int i=; i<n; i++)//分别求出后一项与前一项的比值
         {
             g=gcd(a[i],a[i-]);
             p1[k]=a[i]/g;
             p2[k]=a[i-]/g;
             k++;
         }
         double t=;
         long long int t1,t2,tt1,tt2;

         for(int i=; i<k; i++)//遍历每一个比值，用大的除以小的，找出最小的公比
             for(int j=i+; j<k; 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(1.0*t1/t2<t)
                 {
                     t=1.0*t1/t2;
                     tt1=t1;
                     tt2=t2;
                 }
             }
         g=gcd(tt1,tt2);
         cout<<tt1/g<<"/"<<tt2/g<<endl;
     }

     return ;
 }