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

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

1. 方程整数解

• 本题总分：3分

• 问题描述

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

  

  这个方程有整数解吗？有：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进行解决

  

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

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

  

• 注意

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

---

• 解析

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