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

最新推荐文章于 2022-10-31 15:18:54 发布

越吵闹♪越孤单

最新推荐文章于 2022-10-31 15:18:54 发布

阅读量820

点赞数 2

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

本文链接：https://blog.youkuaiyun.com/nosympathy/article/details/113431614

版权

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

5 篇文章

订阅专栏

1 奖券数目

题目：

有些人很迷信数字，比如带“4”的数字，认为和“死”谐音，就觉得不吉利。
虽然这些说法纯属无稽之谈，但有时还要迎合大众的需求。某抽奖活动的奖券号码是5位数（10000-99999），要求其中不要出现带“4”的号码，主办单位请你计算一下，如果任何两张奖券不重号，最多可发出奖券多少张。

请提交该数字（一个整数），不要写任何多余的内容或说明性文字。

题解：
求10000-99999中不含数字4的数的个数，将每个数字枚举逐个排除，代码如下：

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

int ans = 100000-10000;

int main()
{
	for (int i = 10000; i <= 99999; i ++)
	{		 if(i/10000==4||i%10000/1000==4||i%1000/100==4||i%100/10==4||i%10==4)
			ans --;
	} 
	cout << ans << endl;
	return 0;
}

2 星系炸弹

题目：

在X星系的广袤空间中漂浮着许多X星人造“炸弹”，用来作为宇宙中的路标。每个炸弹都可以设定多少天之后爆炸。
比如：阿尔法炸弹2015年1月1日放置，定时为15天，则它在2015年1月16日爆炸。
有一个贝塔炸弹，2014年11月9日放置，定时为1000天，请你计算它爆炸的准确日期。

请填写该日期，格式为 yyyy-mm-dd 即4位年份2位月份2位日期。比如：2015-02-19
请严格按照格式书写。不能出现其它文字或符号。

题解：
计算日期，可用Excel，累加年份和月份，直到接近准确日期。表格操作如下：在这里插入图片描述

3 三羊献瑞

题目：

观察下面的加法算式：

其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。

请你填写“三羊献瑞”所代表的4位数字（答案唯一），不要填写任何多余内容。

题解：
不同汉字代表不同数字,观察图片可知有8种不同数字,一共0-9,可用全排列函数next_permutation（），将0-9存入vector类型中，依次枚举，将每次排列的前八位填入算式，成立的则为答案，另外需要排除“祥”和“三”为0的情况，代码如下：

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

vector<int> v;

void check(vector<int> v)
{
	int a = v[0]*1000+v[1]*100+v[2]*10+v[3];//“祥瑞生辉”
	int b = v[4]*1000+v[5]*100+v[6]*10+v[1];//“三羊献瑞”
	int c = v[4]*10000+v[5]*1000+v[2]*100+v[1]*10+v[7];//“三羊生瑞气”
	if (a + b == c && v[0]!=0 && v[4]!=0)
		cout << b << endl;
}

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

4 格子中输出

题目：

StringInGrid函数会在一个指定大小的格子中打印指定的字符串。要求字符串在水平、垂直两个方向上都居中。如果字符串太长，就截断。
如果不能恰好居中，可以稍稍偏左或者偏上一点。

下面的程序实现这个逻辑，请填写划线部分缺少的代码。

#include <stdio.h>
#include <string.h>

void StringInGrid(int width, int height, const char* s)
{
	int i,k;
	char buf[1000];
	strcpy(buf, s);
	if(strlen(s)>width-2) buf[width-2]=0;
	
	printf("+");
	for(i=0;i<width-2;i++) printf("-");
	printf("+\n");
	
	for(k=1; k<(height-1)/2;k++){
		printf("|");
		for(i=0;i<width-2;i++) printf(" ");
		printf("|\n");
	}
	
	printf("|");
	
	printf("%*s%s%*s",_____________________________________________);  //填空
	          
	printf("|\n");
	
	for(k=(height-1)/2+1; k<height-1; k++){
		printf("|");
		for(i=0;i<width-2;i++) printf(" ");
		printf("|\n");
	}	
	
	printf("+");
	for(i=0;i<width-2;i++) printf("-");
	printf("+\n");	
}

int main()
{
	StringInGrid(20,6,"abcd1234");
	return 0;
}

对于题目中数据，应该输出：

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

题解：
观察代码可看出缺失部分为输出中间的字符串,printf中格式化的写法有个生僻的用法，%*s时，先提供一个动态的宽度值,再提供串的值。即空内分别填字符串左边空格的长度,空格,拷贝过来的字符串,字符串右边空格的长度,空格五项,按图中长度可算出字符串左右边空格的长度, 在这里插入图片描述
即(width-2-strlen(buf))/2,"",buf,width-2-strlen(buf)-(width-2-strlen(buf))/2,""

5 九数组分数

题目：

1,2,3…9 这九个数字组成一个分数，其值恰好为1/3，如何组法？

下面的程序实现了该功能，请填写划线部分缺失的代码。

#include <stdio.h>

void test(int x[])
{
	int a = x[0]*1000 + x[1]*100 + x[2]*10 + x[3];
	int b = x[4]*10000 + x[5]*1000 + x[6]*100 + x[7]*10 + x[8];
	
	if(a*3==b) printf("%d / %d\n", a, b);
}

void f(int x[], int k)
{
	int i,t;
	if(k>=9){
		test(x);
		return;
	}
	
	for(i=k; i<9; i++){
		{t=x[k]; x[k]=x[i]; x[i]=t;}
		f(x,k+1);
		_____________________________________________ // 填空处
	}
}
	
int main()
{
	int x[] = {1,2,3,4,5,6,7,8,9};
	f(x,0);	
	return 0;
}

题解：
1-9九个数字组成分数使其值恰好为1/3,使用全排列方法逐个判断是否符合题意，题目中借用递归函数f()实现1-9的全排列，利用k实现两个数字互相交换得到全排列，交换一次传递到下次递归，再实现交换，直到k=9时说明排列完毕，将数组传入测试函数测试是否符合题意，已知每次交换传值后需要保留交换前的状态，则推知填空处是交换的回溯{t=x[k]; x[k]=x[i]; x[i]=t;}，即再将两数交换回来。

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

6 加法变乘法

题目：

我们都知道：1+2+3+ … + 49 = 1225 现在要求你把其中两个不相邻的加号变成乘号，使得结果为2015

比如： 1+2+3+…+1011+12+…+2728+29+…+49 = 2015 就是符合要求的答案。

请你寻找另外一个可能的答案，并把位置靠前的那个乘号左边的数字提交（对于示例，就是提交10）。

注意：需要你提交的是一个整数，不要填写任何多余的内容。

题解：
改变两个不相邻的加号为乘号,使结果为2015,可依次枚举每一种情况,l代表第一个改变的符号左边的数字，r代表第二个改变的符号左边的数字，因为不相邻，则每个r从l+2开始枚举，代码如下:

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

int sum = 1225;

void text(int l)
{
	for (int r = l + 2; r < 50; r ++)
	{
		if (sum-l*2-r*2-2+l*(l+1)+r*(r+1)==2015 && l!=10) 
		{//减去改变部分原来的值，再加上改变部分后来的值，且排除已有的答案 
			cout << l << endl;
			return;
		}
	}
	text(l+1);//测试每一位数字l，并让r从l+2开始枚举 
}

int main()
{
	text(1);
	return 0;
}

7 牌型种数

题目：

小明被劫持到X赌城，被迫与其他3人玩牌。一副扑克牌（去掉大小王牌，共52张），均匀发给4个人，每个人13张。
这时，小明脑子里突然冒出一个问题：如果不考虑花色，只考虑点数，也不考虑自己得到的牌的先后顺序，自己手里能拿到的初始牌型组合一共有多少种呢？

请填写该整数，不要填写任何多余的内容或说明文字。

题解：
13种牌，每种牌4张，求拿到的13张牌的初始牌型组合有多少种，可直接依靠递归，枚举每种牌得到1或2或3或4张或不得到即0张，把这个数据加入当前得到牌的数量cnt，同时计算已经考虑过的牌的种类数k，当考虑过每种牌得到或不得到，即k=13，且计算当前得到的牌的数量即cnt刚好等于13时，条件成立，为一种可行方案。代码如下：

#include<iostream>
using namespace std;

int ans;

void f(int k, int cnt)
{//k代表考虑过的牌的种数，cnt代表已经得到的牌的数量 
	if (cnt > 13 || k > 13) return;
	if (k == 13 && cnt == 13) 
	{//若每种牌都考虑过且已经得到牌的数量刚好为13则为一种方案
		ans ++;
		return;
	}
	for (int i = 0; i < 5; i ++)
		f(k + 1, cnt + i);//i是得到该种牌的数量，选与不选共5种情况 
}

int main()
{
	f(0, 0);
	cout << ans << endl;
	return 0;
}

8 移动距离

题目：

X星球居民小区的楼房全是一样的，并且按矩阵样式排列。其楼房的编号为1,2,3… 当排满一行时，从下一行相邻的楼往反方向排号。
比如：当小区排号宽度为6时，开始情形如下：

1 2 3 4 5 6 12 11 10 9 8 7 13 14 15 …

我们的问题是：已知了两个楼号m和n，需要求出它们之间的最短移动距离（不能斜线方向移动）

输入为3个整数w m n，空格分开，都在1到10000范围内 w为排号宽度，m,n为待计算的楼号。要求输出一个整数，表示m n
两楼间最短移动距离。

例如：
用户输入：
6 8 2
则，程序应该输出：
4

再例如：
用户输入：
4 7 20
则，程序应该输出：
5

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

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

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

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

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

题解：
给两个楼号，求其之间最短移动距离，且不能斜方向移动，即可视为求两个楼号排列的行数和列数，如下观察6为宽度的矩阵：
1 2 3 4 5 6
12 11 10 9 8 7
13 14 15 16 17 18
……
w=6，对于输入的两个楼号，判断其行数时首先需要判断其磨w是否为0，若为0，则说明其为单数行的第w个或者为双数行的第一个，如12，为第2行的第1个，18为第3行的第6个，此时行数即等于楼号除以w的值，同时，该楼号的列数取决于其行数为单数或双数，若为单数，则列数为w；若为双数，则列数为1。若楼号磨w不为0，则可知其行数等于楼号除以w的值再加1，同时，若行数为单数，则说明其是正向排列，其列数等于楼号磨w的值；若行数为双数，则说明其反向排列，其列数等于w减去楼号磨w的值再加1。代码如下：

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

int w, m, n, mm, nn;
int linem, linen;

void check()//求两个楼号的行数和列数
{
	if (m % w == 0)//单数行的第w列或双数行的第一个
	{
		linem = m / w;
		if (linem % 2 != 0) mm = w;
		else mm = 1;
	}
	else//每行中间的数
	{
		linem = m / w + 1;
		if (linem % 2 != 0) mm = m % w;
		else mm = w - m % w + 1;
	}

	if (n % w == 0) 
	{
		linen = n / w;
		if (linen % 2 != 0) nn = w;
		else nn = 1;
	}
	else 
	{
		linen = n / w + 1;
		if (linen % 2 != 0) nn = n % w;
		else nn = w - n % w + 1;
	}
}

int main()
{
	scanf ("%d%d%d", &w, &m, &n);
	check();
	cout << abs(linem-linen)+abs(mm-nn) << endl;
	return 0;
}

9 垒骰子

题目：

赌圣atm晚年迷恋上了垒骰子，就是把骰子一个垒在另一个上边，不能歪歪扭扭，要垒成方柱体。经过长期观察，atm
发现了稳定骰子的奥秘：有些数字的面贴着会互相排斥！我们先来规范一下骰子：1 的对面是 4，2 的对面是 5，3 的对面是 6。假设有 m
组互斥现象，每组中的那两个数字的面紧贴在一起，骰子就不能稳定的垒起来。 atm想计算一下有多少种不同的可能的垒骰子方式。
两种垒骰子方式相同，当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。由于方案数可能过多，请输出模 10^9 + 7 的结果。

不要小看了 atm 的骰子数量哦～

「输入格式」
第一行两个整数 n m n表示骰子数目接下来 m 行，每行两个整数 a b ，表示 a 和 b 数字不能紧贴在一起。

「输出格式」
一行一个数，表示答案模 10^9 + 7 的结果。

「样例输入」
2 1
1 2

「样例输出」
544

「数据范围」
对于 30% 的数据：n <= 5 对于 60% 的数据：n <= 100 对于 100% 的数据：0 < n <=
10^9, m <= 36

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

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

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

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

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

题解：
给出相互排斥的数字和需要排列的骰子数，求不同可能的垒骰子方式，由于数据过大，用递归方法可能超时，需考虑其他方法，因为每个骰子上面对应的骰子的数字都最多有6种可能，只需要排除相互排斥的数字，所以可以把每个面与可能对应的面赋成矩阵，可以紧贴的两个数字对应的矩阵处赋为1，相互冲突的对应矩阵处即赋为0，如：
若1和2相互排斥，因为4的对面是1,5的对面是2，因此下面是4的骰子上面不能放下面是2的骰子，下面是5的骰子上面不能放下面是1的骰子，即冲突矩阵：
1 1 1 1 1 1
1 1 1 1 1 1
1 1 1 1 1 1
1 0 1 1 1 1
0 1 1 1 1 1
1 1 1 1 1 1
这样求排列n个骰子的方式数可以直接求冲突矩阵的n-1次方，把其中每个数字加起来磨去10的9次方加7，又因为每个垒的骰子除了上下两面的数字四面的数字都能够随意排列，因此需要将答案再乘以4的n次方。代码如下：

#include<iostream>
#include<map>
#include<cstdio> 
using namespace std;
typedef long long LL;
#define MOD 1000000007 

int n, m;
map<int, int> op;
//存入每一面对面的数字
void init(){ 
	op[1] = 4;
	op[4] = 1;
	op[2] = 5;
	op[5] = 2;
	op[3] = 6;
	op[6] = 3;
}
//矩阵初始化
struct M{ 
	LL a[6][6];
	M(){
		for (int i = 0; i < 6; i ++)
			for (int j = 0; j < 6; j ++)
				a[i][j] = 1;
	}
};
//两个矩阵相乘 
M mMultiply(M m1, M m2)
{
	M ans;
	for (int i = 0; i < 6; i ++)
		for (int j = 0; j < 6; j ++)
		{
			ans.a[i][j] = 0;
			for (int k = 0; k < 6; k ++)
				ans.a[i][j] = (ans.a[i][j] + m1.a[i][k] * m2.a[k][j]) % MOD;
		}
//两矩阵相乘，即为前一个矩阵的每一行乘以后一个矩阵的每一列，即矩阵m1的i行第k列数字乘以矩阵m2的k行第j列数字 
	return ans;
}

//快速幂变形，求M的k次方 
M mPow(M m, int k)
{
	M ans;
	for (int i = 0; i < 6; i ++)
		for (int j = 0; j < 6; j ++)
			if (i == j) ans.a[i][j] = 1;
			else ans.a[i][j] = 0; //单位矩阵赋值，对角线上为1 
	while(k != 0)
	{
		if (k & 1)
		{
			ans = mMultiply(ans, m);//两矩阵相乘 
		}
		m = mMultiply(m, m);
		k >>= 1;
	} 
	return ans;
}
int main()
{
	init();
	scanf ("%d %d", &n, &m);
	M cMatrix;
	for (int i = 0; i < m; i ++)
	{
		int a, b;
		scanf ("%d %d", &a, &b);
		cMatrix.a[op[a]-1][b-1] = 0; 
		cMatrix.a[op[b]-1][a-1] = 0;
		//初始化冲突矩阵，将相互排斥的面的对应矩阵处赋为0
	}
	
	M cMatrix_n_1 = mPow(cMatrix, n - 1);//求冲突矩阵的n-1次方
	
	LL ans = 0;
	for (int j = 0; j < 6; j ++)
		for (int i = 0; i < 6; i ++)
			ans = (ans + cMatrix_n_1.a[i][j]) % MOD;
			
	//快速幂，求4的n次方 
	LL t = 1, tmp = 4, p = n;
	while (p != 0)
	{
		if (p & 1) t = (t * tmp) % MOD;
		tmp = (tmp * tmp) % MOD;
		p >>= 1;//将p的二进制右移一位 
	} 
	printf ("%lli", ans * t % MOD);
	return 0;
}

10 生命之树

题目：

在X森林里，上帝创建了生命之树。

他给每棵树的每个节点（叶子也称为一个节点）上，都标了一个整数，代表这个点的和谐值。
上帝要在这棵树内选出一个非空节点集S，使得对于S中的任意两个点a,b，都存在一个点列 {a, v1, v2, …, vk, b}
使得这个点列中的每个点都是S里面的元素，且序列中相邻两个点间有一条边相连。

在这个前提下，上帝要使得S中的点所对应的整数的和尽量大。这个最大的和就是上帝给生命之树的评分。

经过atm的努力，他已经知道了上帝给每棵树上每个节点上的整数。但是由于 atm
不擅长计算，他不知道怎样有效的求评分。他需要你为他写一个程序来计算一棵树的分数。

「输入格式」
第一行一个整数 n 表示这棵树有 n 个节点。第二行 n 个整数，依次表示每个节点的评分。接下来 n-1 行，每行 2个整数 u, v，表示存在一条 u 到 v 的边。由于这是一棵树，所以是不存在环的。

「输出格式」
输出一行一个数，表示上帝给这棵树的分数。

「样例输入」
5
1 -2 -3 4 5
4 2
3 1
1 2
2 5

「样例输出」
8

「数据范围」
对于 30% 的数据，n <= 10 对于 100% 的数据，0 < n <= 10^5, 每个节点的评分的绝对值不超过10^6 。

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

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

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

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

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

题解：
在给出的树与权值内求非空节点集S，要求其内任意两个点a, b都存在a到b的路径，已知一个树的集合中，每个节点要到另一个节点，都需要经过其共同的根节点，即存在这两个节点的连通子集必然存在其根节点，则可以通过计算以每个节点为根与其孩子节点所得到的集合，算出每个节点作为根的权和，找出最大权和即S中对应整数的和，代码如下：

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

const int N = 1e5 + 5;
int ans, n;
int w[N], ww[N];//w每个点权值,ww每个点作为根节点时能得到的最大权和 
vector<int> g[N];//邻接表 
//以root为根，算出最大权和 
void dfs(int root, int fa)
{
	ww[root] = w[root];
	for (int i = 0; i < g[root].size(); i ++)
	{
		int son = g[root][i];
		if (son != fa)//遍历每一个孩子节点
		{
			dfs(son, root);
			if (ww[son] > 0)//将每个正权节点加入权和的集合
				ww[root] += ww[son];
		}
	}
	if (ww[root] > ans) ans = ww[root];//判断最大权和
}
int main()
{
	scanf ("%d", &n);
	for (int i = 1; i <= n; i ++)
		scanf ("%d", &w[i]);
	for (int j = 0; j < n - 1; j ++)
	{
		int u, v;
		scanf ("%d %d", &u, &v);
		g[u].push_back(v);
		g[v].push_back(u);
	}
	dfs(1, 0);
	printf ("%d\n", ans);
	return 0;
}