C/C++ 第六届蓝桥杯大赛个人赛省赛（大学A组）题解

最新推荐文章于 2024-04-14 09:08:27 发布

陈陈陈Chann

最新推荐文章于 2024-04-14 09:08:27 发布

阅读量768

点赞数 1

分类专栏： # 蓝桥杯文章标签：算法 c++ 数据结构

本文链接：https://blog.csdn.net/weixin_46348799/article/details/108108917

版权

蓝桥杯专栏收录该内容

8 篇文章 10 订阅

订阅专栏

文章目录

题目	类型
方程整数解	结果填空
星系炸弹	结果填空
奇妙的数字	结果填空
格子中输出	代码填空
九数组分数	代码填空
牌型种数	结果填空
手链样式	结果填空
饮料换购	程序设计
垒骰子	程序设计
灾后重建	程序设计

1. 方程整数解

本题总分：3分
问题描述

方程: a² + b² + c² = 1000
（或参见下图）

这个方程有整数解吗？有：a,b,c=6,8,30 就是一组解。
你能算出另一组合适的解吗？

请填写该解中最小的数字。
注意

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

解析

实际上，只需要找到满足该方程的非负整数解，然后找到最大的整数，取其负值即可。

#include<iostream>
using namespace std;

int main()
{
	int ans = 0;
	for (int i = 0; i < 32; i++)
	{
		for (int j = 0; j < 32; j++)
		{
			for (int k = 0; k < 32; k++)
			{
				int sum = i * i + j * j + k * k;
				if (sum == 1000)
				{
					ans = max(ans, max(i, max(j, k)));
				}
			}
		}
	}
	cout << "-" << ans;
	return 0;
}

答案

-30

2. 星系炸弹

本题总分：5分
问题描述

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

请填写该日期，格式为 yyyy-mm-dd 即4位年份2位月份2位日期。比如：2015-02-19
注意

请严格按照格式书写。不能出现其它文字或符号。

解析

该题可以用Excel进行解决

在A1中输入：2014-11-9

在B1中输入：=A1+1000

因此，答案为2017-08-05
答案

2017-08-05

3. 奇妙的数字

本题总分：9分
问题描述

小明发现了一个奇妙的数字。它的平方和立方正好把0~9的10个数字每个用且只用了一次。
你能猜出这个数字是多少吗？
注意

请填写该数字，不要填写任何多余的内容。

解析

#include<iostream>
using namespace std;

int main()
{
	bool find = false;
	for (int i = 0; i < 31427; i++)
	{
		int num[10] = { 0 };
		int square = i * i;
		int cube = i * i * i;
		
		while (square)
		{
			num[square % 10]++;
			square /= 10;
		}
		while (cube)
		{
			num[cube % 10] ++;
			cube /= 10;
		}

		for (int j = 0; j < 10; j++)
		{
			if (num[j] != 1) break;
			else if (j == 9 && num[j] == 1) find = true;
		}

		if (find)
		{
			cout << i;
			break;
		}
	}
	return 0;
}

答案

69

4. 格子中输出

本题总分：11分

问题描述

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

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

在这里插入图片描述

注意

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

解析

%*s表示控制宽度

答案

(width - strlen(buf)) / 2 - 1, "", buf, (width - strlen(buf)) / 2 - 1, ""

5. 九数组分数

本题总分：15分

问题描述

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

注意

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

解析

想法跟dfs中的回溯一样
答案
```
{t = x[k]; x[k] = x[i]; x[i] = t; }
```

6. 牌型种数

本题总分：17分
问题描述

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

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

解析

#include <iostream>
using namespace std;
int ans;

void poker(int a, int sum) //a:序号为1-13的卡牌中的一种，sum:目前手上的卡牌数
{
	if (sum == 13)
	{
		ans++;
		return;
	}
	if (a == 14 || sum > 13) return;
	//拿每种卡牌的0~4张
	for (int i = 0; i <= 4; i++) poker(a + 1, sum + i);
}

int main()
{
	poker(1, 0);
	cout << ans;
	return 0;
}

答案

3598180

7. 手链样式

本题总分：21分
问题描述

小明有3颗红珊瑚，4颗白珊瑚，5颗黄玛瑙。
他想用它们串成一圈作为手链，送给女朋友。
现在小明想知道：如果考虑手链可以随意转动或翻转，一共可以有多少不同的组合样式呢？
注意

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

解析

程序中为不考虑翻转的情况，因此翻转之后应该将其除以2得到答案。

#include <iostream>
using namespace std;
int ans;
string s_black;
string Find[5005];
int len;

void check(string s)
{
	bool same = false;
	int i;
	string old_s = s;
	for (i = 0; i < 12; i++)
	{
		if (same) break;
		string new_s;
		for (int j = 1; j < 12; j++) new_s += old_s[j];
		new_s += old_s[0];
		for (int j = 0; j < len; j++)
		{
			if (Find[j] == new_s)
			{
				same = true;
				break;
			}
			if (Find[j] == "") break;
		}
		old_s = new_s;
	}
	if (i == 12)
	{
		Find[len++] = s;
		ans++;
	}
}

void link(int a, int b, int c, string s)
{
	if (a == 0 && b == 0 && c == 0)
	{
		check(s);
		return;
	}
	if (a < 0 || b < 0 || c < 0) return;
	link(a - 1, b, c, s + 'a');
	link(a, b - 1, c, s + 'b');
	link(a, b, c - 1, s + 'c');
}

int main()
{
	link(3, 4, 5, s_black);
	cout << (ans + 30) / 2;
	return 0;
}

答案

1170

8. 饮料换购

本题总分：13分
问题描述

乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去(但不允许暂借或赊账)。

请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的n瓶饮料，最后他一共能喝到多少瓶饮料。
输入格式

一个整数n，表示开始购买的饮料数量（0<n<10000）
输出格式

一个整数，表示实际得到的饮料数
样例输入

100
样例输出

149
样例输入

101
样例输出

151
资源约定

峰值内存消耗 < 256M
CPU消耗 < 1000ms
注意

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

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

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

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

答案

#include <iostream>
using namespace std;
int ans;

void drink(int num)
{
	if (num < 3) return;
	ans++;
	drink(num - 2);
}

int main()
{
	int n;
	cin >> n;
	drink(n);
	cout << ans + n;
	return 0;
}

9. 垒骰子

本题总分：25分
问题描述

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

不要小看了 atm 的骰子数量哦～
输入格式

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

一行一个数，表示答案模 10⁹ + 7 的结果。
样例输入

2 1
1 2
样例输出

544
数据范围

对于 30% 的数据：n <= 5
对于 60% 的数据：n <= 100
对于 100% 的数据：0 < n <= 10⁹, m <= 36
资源约定

峰值内存消耗 < 256M
CPU消耗 < 2000ms
注意

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

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

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

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

答案

#include <iostream>

using namespace std;

// 总骰子数
int N = 0;
// 映射某一面与其对面的面编号，0 位置不用
int Map[7] = { 0, 4, 5, 6, 1, 2, 3 };
// 存储互斥条件
bool Forbids[7][7] = { false };

#define MOD 1000000007

// 计算 sum += r * 4，并按题目规定取余
uint64_t round_add_mul(uint64_t sum, uint64_t r)
{
    if (r == 0)
        return sum;

    sum = sum % MOD;
    r = r % MOD;
    r = (4 * r) % MOD;

    return (sum + r) % MOD;
}

// 递推计算，top 为上一个骰子向上的面，remain 为还剩下多少个骰子
uint64_t f(int top, int remain)
{
    // 当骰子排列完时，结束，这里以 0 作为终结以及返回 1 是为了恰好和下面算法对应
    if (remain == 0)
        return 1;

    // sum 保存了从当前骰子开始，到最后一个骰子的排列数量
    uint64_t sum = 0;
    // 依次遍历每个面进行测试，这里的 i 为当前骰子的底面
    // 所有可能的情况为底面取 1 的情况 + 底面取 2 的情况 + ...
    for (int i(1); i != 7; ++i)
    {
        // 当前底面和上一个骰子的顶面是否互斥，互斥时，这趟计算结果是不能用的
        if (Forbids[top][i])
            continue;

        // 对剩下的骰子进行排列，新的顶面数据由 Map 转换
        auto r = f(Map[i], remain - 1);
        // 剩下的骰子总共有 r 种排列组合，由于当前顶面、底面不变，还可以旋转 4 次，所以 sum += r * 4
        // 假如当前骰子是最后一个骰子，下一次计算返回 1，这里依然可以用同样的公式计算 sum += 1 * 4
        // 这是为什么上面的返回条件是以 0 结束并返回 1 的原因
        sum = round_add_mul(sum, r);
    }

    // 当前排列数量算清楚之后，再交给上一轮，乘以上一个骰子的那个 4
    return sum;
}

int main()
{
    int m;
    cin >> N >> m;

    for (int i(0); i != m; ++i)
    {
        int a, b;
        cin >> a >> b;

        Forbids[a][b] = true;
        Forbids[b][a] = true;
    }

    uint64_t sum = 0;
    // 此处 i 为第一个骰子的顶面数据
    for (int i(1); i != 7; ++i)
    {
        // 对于第一个骰子，无需计算互斥，直接遍历
        auto r = f(i, N - 1);
        // 拿到剩下的排列数据 r 之后，r * 4 就是当前以 i 为顶面的排列个数
        // 把 6 个顶面的排列个数相加，就是最终结果
        sum = round_add_mul(sum, r);
    }

    cout << sum << endl;

    return 0;
}

引用：https://blog.sbw.so/u/lanqiao-cpp-dice-combination-code.html

10. 灾后重建

本题总分：31分
问题描述

Pear市一共有N（<=50000）个居民点，居民点之间有M（<=200000）条双向道路相连。这些居民点两两之间都可以通过双向道路到达。这种情况一直持续到最近，一次严重的地震毁坏了全部M条道路。
震后，Pear打算修复其中一些道路，修理第i条道路需要Pi的时间。不过，Pear并不打算让全部的点连通，而是选择一些标号特殊的点让他们连通。
Pear有Q（<=50000）次询问，每次询问，他会选择所有编号在[l,r]之间，并且编号 mod K = C 的点，修理一些路使得它们连通。由于所有道路的修理可以同时开工，所以完成修理的时间取决于花费时间最长的一条路，即涉及到的道路中Pi的最大值。

你能帮助Pear计算出每次询问时需要花费的最少时间么？这里询问是独立的，也就是上一个询问里的修理计划并没有付诸行动。
输入格式

第一行三个正整数N、M、Q，含义如题面所述。
接下来M行，每行三个正整数Xi、Yi、Pi，表示一条连接Xi和Yi的双向道路，修复需要Pi的时间。可能有自环，可能有重边。1<=Pi<=1000000。

接下来Q行，每行四个正整数Li、Ri、Ki、Ci，表示这次询问的点是[Li,Ri]区间中所有编号Mod Ki=Ci的点。保证参与询问的点至少有两个。
输出格式

输出Q行，每行一个正整数表示对应询问的答案。
样例输入

7 10 4
1 3 10
2 6 9
4 1 5
3 7 4
3 6 9
1 5 8
2 7 4
3 2 10
1 7 6
7 6 9
1 7 1 0
1 7 3 1
2 5 1 0
3 7 2 1
样例输出

9
6
8
8
数据范围

对于20%的数据，N,M,Q<=30
对于40%的数据，N,M,Q<=2000
对于100%的数据，N<=50000,M<=2*10⁵,Q<=50000. Pi<=10⁶. Li,Ri,Ki均在[1,N]范围内，Ci在[0,对应询问的Ki)范围内。
资源约定

峰值内存消耗 < 256M
CPU消耗 < 5000ms
注意

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

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

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

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

答案

#pragma GCC optimize(2)
#include <cstdio>
#include <algorithm>
#include <vector>
#include <iterator>
#include <cmath>
#include <cstring>
#include <utility>

const int maxn = 5e4 + 5;

struct node
{
	int u, v, w;
	bool operator<(const node& x)const
	{
		return w < x.w;
	}
}edge[200005];

std::vector<node> v;
std::vector<std::pair<int, int> > G[maxn];
int a[maxn], res[maxn], dep[maxn], fa[maxn], Fa[maxn][17], ma[maxn][17], n, m, q;

int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }

void dfs(int u, int fa)
{
	dep[u] = dep[fa] + 1;
	Fa[u][0] = fa;
	for (int i = 1; (1 << i) <= dep[u]; i++)
		Fa[u][i] = Fa[Fa[u][i - 1]][i - 1],
		ma[u][i] = std::max(ma[u][i - 1], ma[Fa[u][i - 1]][i - 1]);
	for (std::vector<std::pair<int, int> >::iterator i = G[u].begin(); i != G[u].end(); ++i)
	{
		if (i->first == fa) continue;
		ma[i->first][0] = i->second;
		dfs(i->first, u);
	}
}
int getlca_max(int x, int y)
{
	int ans = -0x3f3f3f3f;
	if (dep[x] < dep[y]) std::swap(x, y);
	for (int i = 16; i >= 0; i--) if ((1 << i) <= dep[x] - dep[y])
		ans = std::max(ans, ma[x][i]), x = Fa[x][i];
	if (x == y) return ans;
	for (int i = 16; i >= 0; i--)
		if (Fa[x][i] != Fa[y][i])
			ans = std::max(ans, std::max(ma[y][i], ma[x][i])),
			x = Fa[x][i], y = Fa[y][i];
	return std::max(ans, std::max(ma[x][0], ma[y][0]));
}
struct SegTree
{
	int maxx[maxn << 2];
	void build(int o, int l, int r)
	{
		maxx[o] = 0;
		if (l == r) { maxx[o] = a[l]; return; }
		int m = (l + r) >> 1;
		build(o << 1, l, m); build(o << 1 | 1, m + 1, r);
		maxx[o] = std::max(maxx[o << 1], maxx[o << 1 | 1]);
	}
	int query(int o, int l, int r, int ql, int qr)
	{
		if (ql <= l && r <= qr)return maxx[o];
		int m = (l + r) >> 1;
		int ans = -0x3f3f3f3f;
		if (ql <= m) ans = std::max(ans, query(o << 1, l, m, ql, qr));
		if (qr > m) ans = std::max(ans, query(o << 1 | 1, m + 1, r, ql, qr));
		return ans;
	}
}st;

struct query
{
	int l, r, mod, c, id;
	bool operator<(const query& x)const
	{
		if (mod == x.mod)return c < x.c;
		else return mod < x.mod;
	}
}Q[maxn];
int main()
{
#ifdef LOCAL
	freopen("input.in", "r", stdin);
#endif
	scanf("%d%d%d", &n, &m, &q);
	for (int i = 1; i <= n; i++) fa[i] = i;
	for (int i = 1; i <= m; i++)
	{
		scanf("%d%d%d", &edge[i].u, &edge[i].v, &edge[i].w);
	}
	std::sort(edge + 1, edge + m + 1);
	int cnt = 0;
	for (int i = 1; i <= m; i++)
	{
		int x = find(edge[i].u), y = find(edge[i].v);
		if (x != y)
		{
			fa[x] = y; cnt++;
			G[edge[i].u].push_back(std::make_pair(edge[i].v, edge[i].w));
			G[edge[i].v].push_back(std::make_pair(edge[i].u, edge[i].w));
		}
		if (cnt == n - 1)break;
	}
	dfs(1, 0);
	for (int i = 1; i <= q; i++)
	{
		int l, r, mod, c; scanf("%d%d%d%d", &Q[i].l, &Q[i].r, &Q[i].mod, &Q[i].c);
		Q[i].id = i;
	}
	std::sort(Q + 1, Q + q + 1);
	for (int i = 1; i <= q; i++)
	{
		int l = Q[i].l, r = Q[i].r, mod = Q[i].mod, c = Q[i].c;
		if (mod > sqrt(n))
		{
			int L = l - l % mod + c; if (L < l)L += mod;
			int ans = -0x3f3f3f3f;
			for (int j = L; j <= r - mod; j += mod)
				ans = std::max(ans, getlca_max(j, j + mod));
			res[Q[i].id] = ans;
		}
		else
		{
			if (Q[i].mod != Q[i - 1].mod || Q[i].c != Q[i - 1].c)
			{
				memset(a, 0, sizeof a);
				for (int j = c ? c : mod; j + mod <= n; j += mod)
					a[j] = getlca_max(j, j + mod);
				st.build(1, 1, n);
			}
			res[Q[i].id] = st.query(1, 1, n, l, r - mod);
		}
	}
	for (int i = 1; i <= q; i++)printf("%d\n", res[i]);
	return 0;
}

引用：https://blog.csdn.net/wzazzy/article/details/104642149

陈陈陈Chann

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
C/C++ 第六届蓝桥杯大赛个人赛省赛（大学A组）题解

C/C++ 第六届蓝桥杯大赛个人赛省赛（大学A组）题解题目类型方程整数解结果填空星系炸弹结果填空奇妙的数字结果填空格子中输出代码填空九数组分数代码填空牌型种数结果填空手链样式结果填空饮料换购程序设计垒骰子程序设计灾后重建程序设计1. 方程整数解本题总分：3分问题描述方程: a2 + b2 + c2 = 1000（或参见下图）这个方程有整数解吗？有：a,b,c=6,8,30 就是一组解。
复制链接

扫一扫