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

文章目录

    • 1. 方程整数解
    • 2. 星系炸弹
    • 3. 奇妙的数字
    • 4. 格子中输出
    • 5. 九数组分数
    • 6. 牌型种数
    • 7. 手链样式
    • 8. 饮料换购
    • 9. 垒骰子
    • 10. 灾后重建

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

1. 方程整数解

  • 本题总分:3分

  • 问题描述

    方程: a2 + b2 + c2 = 1000
    (或参见下图)

    C/C++ 第六届蓝桥杯大赛个人赛省赛(大学A组) 题解_第1张图片

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

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

  • 注意

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


  • 解析

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

    #include
    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进行解决

    C/C++ 第六届蓝桥杯大赛个人赛省赛(大学A组) 题解_第2张图片

    在A1中输入:2014-11-9

    在B1中输入:=A1+1000

    因此,答案为2017-08-05

  • 答案

    2017-08-05


3. 奇妙的数字

  • 本题总分:9分

  • 问题描述

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

  • 注意

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


  • 解析

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

    对于题目中数据,应该输出:

    C/C++ 第六届蓝桥杯大赛个人赛省赛(大学A组) 题解_第3张图片

  • 注意

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


  • 解析

    %*s表示控制宽度

  • 答案

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

5. 九数组分数

  • 本题总分:15分

  • 问题描述

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

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

    #include 
    
    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 
    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 
    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

  • 输出格式

    一个整数,表示实际得到的饮料数

  • 样例输入

    100

  • 样例输出

    149

  • 样例输入

    101

  • 样例输出

    151

  • 资源约定

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

  • 注意

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

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

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

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


  • 答案

    #include 
    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想计算一下有多少种不同的可能的垒骰子方式。
    两种垒骰子方式相同,当且仅当这两种方式中对应高度的骰子的对应数字的朝向都相同。
    由于方案数可能过多,请输出模 109 + 7 的结果。

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

  • 输入格式

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

  • 输出格式

    一行一个数,表示答案模 109 + 7 的结果。

  • 样例输入

    2 1
    1 2

  • 样例输出

    544

  • 数据范围

    对于 30% 的数据:n <= 5
    对于 60% 的数据:n <= 100
    对于 100% 的数据:0 < n <= 109, m <= 36

  • 资源约定

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

  • 注意

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

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

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

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


  • 答案

    #include 
    
    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*105,Q<=50000. Pi<=106. Li,Ri,Ki均在[1,N]范围内,Ci在[0,对应询问的Ki)范围内。

  • 资源约定

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

  • 注意

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

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

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

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


  • 答案

    #pragma GCC optimize(2)
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    
    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

你可能感兴趣的:(#,蓝桥杯,算法,c++,数据结构)