2016 第七届 蓝桥杯C语言B组预赛

第一题：（简单题目）

煤球数目
有一堆煤球，堆成三角棱锥形。具体：
第一层放1个，
第二层3个（排列成三角形），
第三层6个（排列成三角形），
第四层10个（排列成三角形），
....
如果一共有100层，共有多少个煤球？
请填表示煤球总数目的数字。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

答案：

171700

#include<iostream>
using namespace std;
int main()
{
	int n;
	while(cin>>n)
	{	long long int sum=0;
		for(int i=1;i<=n;i++)
	    {
			sum+=(i*i+i)/2;
			cout<<sum<<" ";
	    }
	}
   return 0;
}

第二题：

生日蜡烛
某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。
现在算起来，他一共吹熄了236根蜡烛。
请问，他从多少岁开始过生日party的？
请填写他开始过生日party的年龄数。
注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。

答案：26

#include<iostream>
using namespace std;
int main()
{
	int i,j,sum=0;
	int flag=0;
	for(i=0;i<200;i++)
	{
		sum=i;
		if(flag==1)
			break;
		for(j=i+1;j<200;j++)
		{
			sum+=j;
			if(sum==236)
			{
				flag=1;
				cout<<i<<" "<<j<<endl;
				break;
			}
		}
	}
	return 0;
}

第三题

凑算式

     B      DEF
A + --- + ------- = 10
     C      GHI
     
（如果显示有问题，可以参见【图1.jpg】）   
这个算式中A~I代表1~9的数字，不同的字母代表不同的数字。
比如：
6+8/3+952/714 就是一种解法，
5+3/1+972/486 是另一种解法。
这个算式一共有多少种解法？
注意：你提交应该是个整数，不要填写任何多余的内容或说明性文字。

答案：29

我用了两种做法：

全排列函数：

全排列函数
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
	long long int num[10]={1,2,3,4,5,6,7,8,9};
	int sum=0;
	do
	{
		//for(int i=0;i<9;i++)
		//	cout<<num[i]<<" ";
		//cout<<endl;
		long long int x1,a,b,c,d,x2;
		x1=num[0];
		a=num[1];
		b=num[2];
		c=num[3]*100+num[4]*10+num[5];
		d=num[6]*100+num[7]*10+num[8];
		x2=(a*d+c*b)/(b*d);
		if((a*d+c*b)%(b*d)==0&&x1+x2==10)
		{
			sum++;
		}
		
	}while(next_permutation(num,num+9));
  	cout<<sum<<endl;
}

递归：

递归
#include<iostream>
#include<memory.h>
#include<algorithm>
using namespace std;
int num[10],vis[10];
int sum=0;
void dfs(int x)
{
	if(x==9)
    {
	   long long int x1,a,b,c,d,x2;
		x1=num[0];
		a=num[1];
		b=num[2];
		c=num[3]*100+num[4]*10+num[5];
		d=num[6]*100+num[7]*10+num[8];
		x2=(a*d+c*b)/(b*d);
		if((a*d+c*b)%(b*d)==0&&x1+x2==10)
		{
			sum++;
		}
		return;
	}
	for(int i=1;i<=9;i++)
	{
		if(vis[i]==0)//标记没有重复的 
		{
		    num[x]=i;
		    vis[i]=1;
		    dfs(x+1);
			vis[i]=0;//回溯	
		}
	}
}
int main()
{
  	memset(vis,0,sizeof(vis));	
	dfs(0);
	cout<<sum<<endl;
}

第四题

快速排序


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


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


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


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




#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;
}

注意：只填写缺少的内容，不要书写任何题面已有代码或说明性文字。
答案：swap(a,j,p)

因为之前学过数据结构里面的快速排序，明白快速排序的过程就很容易推出来。

第五题

抽签


X星球要派出一个5人组成的观察团前往W星。
其中：
A国最多可以派出4人。
B国最多可以派出2人。
C国最多可以派出2人。
D国最多可以派出1人。
E国最多可以派出1人。
F国最多可以派出3人。
....


那么最终派往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';
f(a,k+1,m-i,b);
}
}
int main()
{
int  a[N] = {4,2,2,1,1,3};
char b[BUF];
f(a,0,M,b);
return 0;
}


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


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


答案：f(a,k+1,m-i,b);
首先肯定是递归，在根据题意推。运行结果对就是答案。。

第六题

方格填数


如下的10个格子
   +--+--+--+
   |  |  |  |
+--+--+--+--+
|  |  |  |  |
+--+--+--+--+
|  |  |  |
+--+--+--+


（如果显示有问题，也可以参看【图1.jpg】）


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


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


请填写表示方案数目的整数。
。

答案：1580

暴力：

#include<iostream>
#include<memory.h>
#include<algorithm>
using namespace std;
int a[10]={0,1,2,3,4,5,6,7,8,9};
int main()
{
	int sum=0;
	do
	{
		if(abs(a[0]-a[1])!=1&&abs(a[0]-a[6])!=1&&abs(a[0]-a[5])!=1&&abs(a[0]-a[4])!=1
		&&abs(a[2]-a[1])!=1&&abs(a[5]-a[1])!=1&&abs(a[4]-a[1])!=1&&abs(a[3]-a[1])!=1
		&&abs(a[2]-a[3])!=1&&abs(a[2]-a[4])!=1&&
		abs(a[3]-a[4])!=1&&abs(a[3]-a[9])!=1
		&&abs(a[4]-a[5])!=1&&abs(a[5]-a[9])!=1
		&&abs(a[4]-a[9])!=1&&abs(a[4]-a[8])!=1&&abs(a[5]-a[6])!=1&&abs(a[5]-a[7])!=1
		&&abs(a[5]-a[8])!=1&&abs(a[6]-a[7])!=1&&abs(a[6]-a[8])!=1&&abs(a[8]-a[7])!=1
		&&abs(a[8]-a[9])!=1)
		sum++; 
	}while(next_permutation(a,a+10)); 
	cout<<sum<<endl;
}

第七题

如【图1.jpg】, 有12张连在一起的12生肖的邮票。

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


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


请填写表示方案数目的整数。

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

答案：116

解题思路：

//首先从12数中选出5个数 用深搜(保证五个数是递增的,避免重复) 将五个数转化为坐标形式 

// 再判断这5个数是否相连，用广搜

我的代码：

[cpp]  view plain  copy

 

1. //首先从12数中选出5个数 用深搜(保证五个数是递增的,避免重复) 将五个数转化为坐标形式   
2. // 再判断这5个数是否相连，用广搜  
3. #include<iostream>   
4. #include<algorithm>  
5. #include<queue>  
6. #include<memory.h>  
7. using namespace std;  
8. int a[5],vis2[6][6];  
9. int n,vis1[20],k;  
10. int sum=0;  
11. int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};  
12. struct node {  
13.     int x,y;  
14. }s;  
15. int bfs(int x1,int y1)  
16. {  
17.     queue<node>q;  
18.     s.x=x1;  
19.     s.y=y1;  
20.     vis2[x1][y1]=0;  
21.     k=1;  
22.     q.push(s);  
23.     node m,t;  
24.     while(!q.empty())  
25.     {  
26.         t=q.front();  
27.         q.pop();  
28.         for(int i=0;i<4;i++)  
29.         {  
30.             m.x=t.x+dir[i][0];  
31.             m.y=t.y+dir[i][1];  
32.             if(vis2[m.x][m.y]==1&&m.x>=1&&m.x<=3&&m.y>=1&&m.y<=4)  
33.             {  
34.                 k++;  
35.                 vis2[m.x][m.y]=0;  
36.                 cout<<m.x<<" "<<m.y<<endl;  
37.                 q.push(m);  
38.             }  
39.         }  
40.     }  
41.     return k;  
42. }  
43. void dfs(int n)  
44. {  
45.     if(n==5)  
46.     {  
47.         memset(vis2,0,sizeof(vis2));  
48.         int x1,y1;  
49.         for(int i=0;i<5;i++)  
50.         {  
51.             y1=a[i]%4;  
52.             if(y1==0)  
53.             {  
54.               x1=a[i]/4;   
55.               y1=4;  
56.             }  
57.             else  
58.               x1=a[i]/4+1;  
59.             vis2[x1][y1]=1;  
60.         }  
61.         if(bfs(x1,y1)==5)  
62.             sum++;  
63.         return;  
64.     }  
65.     else  
66.     {  
67.         for(int i=1;i<=12;i++)  
68.         {  
69.             if(vis1[i]==0&&i>a[n-1])  
70.             {  
71.                 a[n]=i;     
72.                 vis1[i]=1;  
73.                 dfs(n+1);   
74.                 vis1[i]=0;  
75.             }  
76.         }  
77.     }  
78. }  
79. int main()  
80. {  
81.     memset(vis1,0,sizeof(vis1));  
82.     dfs(0);  
83.     cout<<sum<<endl;  
84. }  

第八题

四平方和


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


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

答案：

#include<iostream>
#include<math.h>
#include<algorithm>
using namespace std;
int ff(int a[],int n)
{
	int m,ok=0;
	m=(int)sqrt(n);
	for(a[0]=0;a[0]<=m;a[0]++)
	{
		if(ok==1||a[0]*a[0]>m)
			return 0;
		for(a[1]=0;a[1]<=m;a[1]++)
			for(a[2]=0;a[2]<=m;a[2]++)
				for(a[3]=0;a[3]<=m;a[3]++)
				{
					int sum=0;
					sum=a[0]*a[0]+a[1]*a[1]+a[2]*a[2]+a[3]*a[3];
					if(sum==n) 
					{
						ok=1;
						sort(a,a+4);
						cout<<a[0]<<"　"<<a[1]<<" "<<a[2]<<" "<<a[3]<<endl;
						return 0;
					}
					if(sum>n)
						break;
				}
      }
   
}
int main()
{
	int a[4],n;
	int ok=0;
	cin>>n;
	ff(a,n);
	return 0;	
}

第九题：

交换瓶子


有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
再例如，输xzc
5
5 4 3 2 1


程序应该输出：
2


资源约定：
峰值内存消耗 < 256M
CPU消耗  < 1000ms


请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。


所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。


注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>， 不能通过工程设置而省略常用头文件。


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

#include<iostream>
#include<math.h>
#include<algorithm>
using namespace std;
int main()
{
   int n,a[10000],b[10005],i,j,sum=0;
   cin>>n;
   for(i=1;i<=n;i++)
   	{
    	cin>>a[i];
        b[a[i]]=i;
    }
    // 5 4 3 2 1  
    // 1 2 3 4 5 
    for(i=1;i<=n;i++)
	{
		if(a[i]!=b[a[i]])//交换下标 
		{
		  sum++;
		  int m,t;
		  m=b[a[i]];//m=1
		  t=b[m];
		  b[m]=b[a[i]];
		  b[a[i]]=t;
		}
	}
	cout<<sum<<endl; 
}

第十题

最大比例


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


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

至今没有思路

转载于:https://www.cnblogs.com/xunalove/p/6809164.html