2016年蓝桥杯省赛C++B组真题与题解

最新推荐文章于 2024-03-25 09:44:16 发布

越吵闹♪越孤单

最新推荐文章于 2024-03-25 09:44:16 发布

阅读量774

点赞数 1

分类专栏：蓝桥杯真题题解文章标签：算法 c++

本文链接：https://blog.csdn.net/nosympathy/article/details/113831302

版权

蓝桥杯真题题解专栏收录该内容

5 篇文章 1 订阅

订阅专栏

1 煤球数目

题目：

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

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

题解：
找规律可知，每一层的煤球数量都是前一层煤球数量加上当层层数，而且只用求最后100层共有的煤球数量，不用求出中间每一层，则可以设置两个量累加，一个量累加上一层的煤球数量加上当层层数，第二个量则累加每一层煤球数，代码如下：

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

int t = 0, ans;

int main()
{
	for (int i = 1; i <= 100; i ++)
	{
		t += i;
		ans += t;
	}
	cout << ans << endl;
	return 0;
}

2 生日蜡烛

题目：

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

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

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

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

题解：
已知蜡烛个数是一串相连的数字相加得到的，则这串数字一定有一个或两个“中间数”，蜡烛数除以过生日的次数则为这个中间数或两个中间数的和，则可以运用表格将236从1开始逐个做除法，如下在这里插入图片描述
，可知236除以4时能得到整数59，若59是唯一的中间数，如图，
可知无法用剩下三个与59相邻的数组成236，则59应是两个中间数的和，已知这两个中间数相邻，则这两个中间数为29和30，如图，即为某君过生日的年龄在这里插入图片描述

3 凑算式

题目：

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

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

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

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

题解：
凑数字的题一般都可以用全排列函数next_permutation()枚举每种情况再逐个判断，本题除了对1-9数字全排列外，还需要注意题目中的算式两个分数是需要通分得到数值的，且通分后的分数也要能够除尽再来判断等式是否成立，代码如下：

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

int ans;
vector<int> q;

void check(vector<int> q)
{
	int a = q[0], b = q[1], c = q[2];
	int d = q[3] * 100 + q[4] * 10 + q[5];
	int e = q[6] * 100 + q[7] * 10 + q[8];
	if ((b*e+d*c) % (c*e) == 0 && (b*e+d*c) / (c*e) == 10-a) ans ++;
}

int main()
{
	for (int i = 1; i <= 9; i ++)
		q.push_back(i);
	
	do{
		check(q);
	} while (next_permutation(q.begin(), q.end()));
	cout << ans << endl;
	return 0;
}

4 快速排序

题目：

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

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

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

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

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

题解：
补充实现快速排序的代码，先把需要填的那一行注释掉，运行程序查看结果，可知原数列：
5，13，6，24，2，8，19，27，6，12，1，17
运行后输出变为：
在这里插入图片描述

按照运行顺序看当quicksort函数传入(a, 0, N - 1)时x=5，则13与1换位置，6与2换位置，得到：
5，1，2，24，6，8，19，27，6，12，13，17
此时传回来的指针q指向24的位置，此时p仍然指向5的位置，r指向17的位置，这时当quicksort函数传入(a, q+1, r)，x=24，运行中27与17换位置，得到：
5，1，2，24，6，8，19，17，6，12，13，27
此时数列与运行出的答案相同，可知后面没有其他改变，但这时排列不正确，仅仅排列了一部分大小，观察可知每次partition运行时，i总要先加一才判断，这样每次i所指的数即传入的p所指的数都没有被纳入判断中，只判断了a[p]后面的数字相对于a[p]的大小，所以需要有针对a[p]的操作，已知最后得到的j处位置的数a[j]一定是小于等于a[p]的，所以可以添加一个交换操作，即交换a[p]与a[j]，这样就把a[p]也考虑进去了，由于代码中已经有交换函数swap，所以可以直接引用，即swap(a, p, j)；再运行一下查看结果是否正确即可。

5 抽签

题目：

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

题解：
输出每种观察团的组合方式，观察f函数，第一次传入的k=0, m=M，有对k和m的判断条件if (k==N)和if (m==0)，但没有改变k和m值的操作，则填空位置需要实现对k和m值的改变，则观察可知此题运用递归同时改变这两个值，即调用函数自身。结合题目，数组a[]给出每个国家最多可派出的人数，函数f中有一个双层循环，第一层以i<=a[k]为判断条件，可知是逐个枚举每个国家派出i个人的结果，第二层循环则是将派出的i个人存入数组b[]记录，则可知第二层循环之后即判定完当前k指向的国家派多少人，这时需要开始判断下一个国家派多少人，k指向每个国家，则传入k+1给下次递归，同时第二层循环后又派出了i个人，则还能派出m-i个人，所以传到下次递归的是m-i，所以最终需要填的是f(a, k+1, m-i, b)；

6 方格填数

题目：

如下的10个格子

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

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

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

题解：
填数字类型题目，仍然是全排列思想，直接利用全排列函数next_permutation(),将0-9存入vector<int>型数组，对每个格子编号，全排列后逐个判断每个格子内数字是否与周围数字是连续数字即可，如图：在这里插入图片描述

对于0代表的格子，需判断1,3,4,5格子内与其是否是连续数字；对于1代表的格子，则需判断2,4,5,6格子内与其是否是连续数字，前面已经判断过的关系后面不用再判断，判断方面用减法求绝对值是否为1判断即可，代码如下：

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

int ans;
vector<int> a;

void check(vector<int> a)
{
	if (abs(a[0]-a[1])==1||abs(a[0]-a[4])==1
		||abs(a[0]-a[3])==1||abs(a[0]-a[5])==1
		
		||abs(a[1]-a[2])==1||abs(a[1]-a[5])==1
		||abs(a[1]-a[4])==1||abs(a[1]-a[6])==1
		
		||abs(a[2]-a[6])==1||abs(a[2]-a[5])==1
		
		||abs(a[3]-a[4])==1||abs(a[3]-a[7])==1
		||abs(a[3]-a[8])==1
		
		||abs(a[4]-a[5])==1||abs(a[4]-a[7])==1
		||abs(a[4]-a[8])==1||abs(a[4]-a[9])==1
		


		||abs(a[5]-a[6])==1||abs(a[5]-a[9])==1
		||abs(a[5]-a[8])==1
		
		||abs(a[6]-a[9])==1
		
		||abs(a[7]-a[8])==1
		
		||abs(a[8]-a[9])==1)
		return;
		ans ++;
}

int main()
{
	for (int i = 0; i <= 9; i ++)
		a.push_back(i);
	do{
		check(a);
	}while (next_permutation(a.begin(), a.end()));
	cout << ans << endl;
	return 0;
}

7 剪邮票

题目：

如
,有12张连在一起的12生肖的邮票。现在你要从中剪下5张来，要求必须是连着的。（仅仅连接一个角不算相连）
比如，

中，粉红色所示部分就是合格的剪取。

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

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

题解：
计算剪取方法数量，先不考虑5张邮票连着的要求，用全排列函数next_permutation()对12张邮票剪掉和不剪掉的情况全排列，a数组存储每张邮票剪或不剪，其中有五张对应数字为1，即剪掉，得出所有情况后，再逐一判断减去的5张邮票是否相连，这里可对剪掉的邮票格子进行深搜求其连通块的个数，如果连通块个数为1，则说明剪掉的5张邮票连在一起，符合题意，代码如下：

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

int ans;
int a[] = {0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1};

void dfs(int g[3][4], int i, int j)
{//分别从每个格子的上下左右四个方向深搜，搜过的格子赋为0 
	g[i][j] = 0;
	if (i-1>=0&&g[i-1][j]==1) dfs(g, i-1, j);
	if (i+1<=2&&g[i+1][j]==1) dfs(g, i+1, j);
	if (j-1>=0&&g[i][j-1]==1) dfs(g, i, j-1);
	if (j+1<=3&&g[i][j+1]==1) dfs(g, i, j+1);
}

bool check(int a[])
{
	int g[3][4];
	for (int i = 0; i < 3; i ++)
		for (int j = 0; j < 4; j ++)
		{//行数i乘每行格子数4+列数j对应每个格子的位置
			if (a[i*4+j]==1) g[i][j] = 1; 
			else g[i][j] = 0;
		}
	int cnt = 0;//连通块个数
	for (int i = 0; i < 3; i ++)
		for (int j = 0; j < 4; j ++)
		{
			if (g[i][j]==1){
				dfs (g, i, j);
				cnt ++; 
			}
		}
	return cnt == 1; //只深搜了一次即5个格子是一个连通块则符合题意
}

int main()
{
	do{//考虑12选5的每种情况再判断选的5个是否为连通块 
		if(check(a)) ans ++;
	}while (next_permutation(a, a + 12));
	cout << ans << endl;
	return 0;
}

8 四平方和

题目：

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

题解：
要查找a, b, c, d四个数的平方和，四重循环时间复杂度太高，可将四个数的平方和拆解为a与b, c与d分别的平方和，构建哈希，提前存储c和d的平方和，并标记每个平方和对应的c，再枚举a和b的平方和，用n减去a, b平方和，得到的值在提前存储的数组中查找，若存在，则对应c和d就是所寻找的答案。
其中查找可用map的find函数，定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器，即若cache.find(c*c+d*d)返回的是cache.end()，相当于没有查找到。

#include<iostream>
#include<algorithm>
#include<cmath>
#include<map>
#include<cstdio>
using namespace std;

int n;
map<int, int> cache;

int main()
{
	scanf ("%d", &n);
	for (int c = 0; c*c <= n/2; c ++)//先存储c*c+d*d的结果 
		for (int d = c; c*c+d*d <= n; d ++)
		{
			if (cache.find(c*c+d*d)==cache.end())//如果已经存在则不用再存储 
				cache[c*c+d*d]=c;
		}
	
	for (int a = 0; a*a <= n/4; a ++)
		for (int b = a; a*a+b*b <= n/2; b ++)
		{
			if (cache.find(n-a*a-b*b)!=cache.end()) 
			{//在cache中查找n减去a*a+b*b后的结果是否存在
				int c = cache[n-a*a-b*b];
				int d = int (sqrt(n-a*a-b*b-c*c));
				printf ("%d %d %d %d\n", a, b, c, d);
				return 0;
			}
		}
	return 0;
}

9 交换瓶子

题目：

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

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

题解：
按照题目的交换思想，枚举每个瓶子的序号，如果瓶子序号不在其正确位置，就找到其正确位置上的瓶子，与其交换，过程中计算交换次数，代码如下：

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

const int N = 10010;
int n, a[N], ans; 

int find(int x)//返回x号瓶子对应的位置
{
	for (int i = 1; i <= n; i ++)
		if (a[i]==x) return i;
	return -1;
}

int main()
{
	scanf ("%d", &n);
	for (int i = 1; i <= n; i ++)
		scanf ("%d", &a[i]);
	for (int i = 1; i <= n; i ++)
	{
		if (a[i]!=i)
		{
			swap(a[i], a[find(i)]);
			ans ++;	
		}
	}
	cout << ans << endl;
	return 0;
}

10 最大比例

题目：

X星球的某个大奖赛设了M级奖励。每个级别的奖金是一个正整数。并且，相邻的两个级别间的比例是个固定值。
也就是说：所有级别的奖金数构成了一个等比数列。比如： 16,24,36,54 其等比值为：3/2

现在，我们随机调查了一些获奖者的奖金数。请你据此推算可能的最大的等比值。

输入格式：
第一行为数字 N (0<N<100)，表示接下的一行包含N个正整数
第二行N个正整数Xi(Xi<1 000 000 000000)，用空格分开。每个整数表示调查到的某人的奖金数额

要求输出：
一个形如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 ，不能通过工程设置而省略常用头文件。

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

题解：
给出一个等比数列中不连续的数字，求等比数列可能的最大比例系数，把给出的数排列后，将每个数与最小的数相除得到多个比例，由等比数列的性质可知，这样求出的每个比例都分别是等比数列公比的x1, x2, x3…次方，求出这些x1, x2, x3…的最大公约数x，即所求的最大比例系数是等比数列公比的x次方。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;
const int N = 110;
typedef long long LL; 

int n;
LL x[N], a[N], b[N];

LL gcd(LL a, LL b)//辗转相除法求a, b的最大公约数
{
	return b ? gcd(b, a % b) : a;
}

LL gcd_sub(LL a, LL b)
{
	if (a < b) swap(a, b);
	if (b == 1) return a;
	return gcd_sub(b, a / b);
}

int main()
{
	scanf ("%d", &n);
	for (int i = 0; i < n; i ++) scanf ("%lld", &x[i]);
	
	sort(x, x + n);
	
	int cnt = 0;
	for (int i = 1; i < n; i ++)
		if (x[i] != x[i - 1])//求每个不同的数对于最小数字的比
		{
			LL d = gcd(x[i], x[0]);
			a[cnt] = x[i] / d;//x[i]和x[0]分别除以其最大公约数得到最简分子分母
			b[cnt] = x[0] / d;
			cnt ++;
		}
	LL up = a[0], down = b[0];
	for (int i = 1; i < cnt; i ++)//分别处理分子和分母
	{
		up = gcd_sub(up, a[i]);
		down = gcd_sub(down, b[i]);
	}
	cout <<  up << '/' << down << endl;
	return 0;
}

越吵闹♪越孤单

关注

1
点赞
踩
9

收藏

觉得还不错? 一键收藏
5
评论
2016年蓝桥杯省赛C++B组真题与题解

1 煤球数目题目：有一堆煤球，堆成三角棱锥形。具体：第一层放1个，第二层3个（排列成三角形），第三层6个（排列成三角形），第四层10个（排列成三角形）， … 如果一共有100层，共有多少个煤球？请填表示煤球总数目的数字。注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。题解：找规律可知，每一层的煤球数量都是前一层煤球数量加上当层层数，而且只用求最后100层共有的煤球数量，不用求出中间每一层，则可以设置两个量累加，一个量累加上一层的煤球数量加上当层层数，第二个量则累加每
复制链接

扫一扫