2021蓝桥杯B组C/C++解析

我爱炼丹 我爱炼丹 博客等级 码龄5年
关注
转载 2022-12-15 21:33:56 884 阅读 开通墨衍会员： AI 帮你选题成稿，GEO 检测让 AI 也搜得到
第十二届蓝桥杯 2021年省赛真题 (C/C++ 大学B组) 蓝桥杯 2021年省赛真题 (C/C++ 大学B组 ） 阅读详情

试题A：

问题描述

          小蓝准备用256MB的内存空间开一个数组，数组的每个元素都是 32位二进制整数，如果不考虑程序占用的空间和维护内存需要的辅助空间，请问256MB的空间可以存储多少个32位二进制整数?

知识点涉及：计算机基础知识

答案：67108864

解析：

        主要考察一些计算机的基础知识，32位二进制数需要站4个字节，256MB=256*1024KB=256*1024字节，所以一共需要存储32位二进制整数的数量就是：256*1024*1024/4=67108864。

代码：

#include <bits/stdc++.h>
int main() {
  printf("%d", 256 * 1024 * 1024 / 4);
  return 0;
}

 试题B：

问题描述

          小蓝有很多数字卡片，每张卡片上都是数字0到9。
小蓝准备用这些卡片来拼一些数，他想从1开始拼出正整数，每拼一个，就保存起来，卡片就不能用来拼其它数了。
小蓝想知道自己能从1拼到多少。
例如，当小蓝有30张卡片，其中0到9各3张，则小蓝可以拼出1到10,但是拼11时卡片1已经只有一张了，不够拼出11。
现在小蓝手里有0到9的卡片各2021张，共20210张，请问小蓝可以从1拼到多少?

提示：建议使用计算机编程解决问题

答案：3181

解析：

  • 涉及知识点：枚举，十进制拆分

  • 做法：初始化 res_num 数组记录当前每种卡牌剩余数量，从1向上枚举需要组合的卡片，直到剩余卡片不足则停止累加，最后成功组合成的卡片即为答案。

代码：

#include <bits/stdc++.h>
using namespace std;

vector<int> Split(int x) { // 将x按照十进制拆分每一位
  vector<int> ret;
  if (x == 0) {
    ret.push_back(0);
    return ret;
  }
  while (x > 0) {
    ret.push_back(x % 10);
    x /= 10;
  }
  return ret;
}

const int maxn = 2021;
int rest_num[10] = {0}; // 记录当前每种数字卡牌剩余数量

bool Sub(const vector<int> &x) { // 将当前需要的数字卡牌从卡牌库中去除，卡牌库剩余卡牌不足则返回false
  for (unsigned int i = 0; i < x.size(); i++) {
    rest_num[x[i]]--;
    if (rest_num[x[i]] < 0) {
      return false;
    }
  }
  return true;
}

int main() {
  for (int i = 0; i < 10; i++) {
    rest_num[i] = maxn;
  }
  int ans = 1;
  while (1) { // 尝试利用剩余卡牌组合出数字ans，剩余卡牌不足则跳出循环
    vector<int> need = Split(ans);
    bool succFlag = Sub(need);
    if (!succFlag) {
      break;
    }
    ans++;
  }
  printf("ans = %d\n", ans - 1);
  return 0;
}

 试题C：

问题描述

        在平面直角坐标系中，两点可以确定一条直线。如果有多点在一条直线上,那么这些点中任意两点确定的直线是同一条。
给定平面上2x3个整点{(x,y)0<x<20y<3xezyeZ，即横坐标是0到1(包含0和1)之间的整数、纵坐标是0到2(包含0和2)之间的整数的点。这些点一共确定了11条不同的直线。
给定平面上20x21个整点{(x,y)0x<20,0y<21,xezyez，即横坐标是0到19(包含0和19)之间的整数、纵坐标是0到20(包含0和20)之间的整数的点。请问这些点一共确定了多少条不同的直线

知识点涉及：枚举、浮点数判

答案：40257

解析：

       

  • 枚举所有点的两两组合，对于每一对两个点的组合就确定了一条直线，对于每条直线都判断其是否和之前已经出现过的直线相同，如果相同则忽略。

  • 判断两个直线是否相同的做法：每个直线存储直线上两个点，对于直线L0(p0,p1)  和直线L1(p2,p3) ，当且仅当点p2  和 p3 均在直线 L1 上，则直线L1  ，L2 重合。

  • 判断一个点是否在直线上的做法：假设存在点 p2 和直线L(p0,p1) ，如果三个点两两之间的距离a+b=c ，则说明三个点在一条直线上。（注意这里判断距离相等因为是浮点类型可能存在误差，所以不可以之间判断是否相等，而是需要判断两个浮点数之间的差是否小于一个较小值，

代码：

#include <bits/stdc++.h>
using namespace std;
struct Point {
  int x, y;
  Point() {}
  Point(int x, int y) {
    this->x = x;
    this->y = y;
  }
};

struct Line {
  Point a, b;
  Line(Point a, Point b) {
    this->a = a;
    this->b = b;
  }
};

vector<Line> lineList;

double Dis(Point p0, Point p1) { // 计算点p0和p1之间的直线距离
  return sqrt((p0.x - p1.x) * (p0.x - p1.x) + (p0.y - p1.y) * (p0.y - p1.y));
}

bool CheckPointInLine(Line x, Point p) { // 检查点p是否在直线x上
  double dis[3];
  dis[0] = Dis(x.a, x.b);
  dis[1] = Dis(x.a, p);
  dis[2] = Dis(x.b, p);
  sort(dis, dis + 3);
  if (fabs(dis[0] + dis[1] - dis[2]) < 1e-5) { // 三点在一条直线则较短两距离相加等于较长距离
    return true;
  } else {
    return false;
  }
}

// 检查当先直线cur是否和之前已经出现过得直线集合（lineList）中的某一直线重合
bool CheckLineRepeat(Line cur) {
  for (unsigned int i = 0; i < lineList.size(); i++) {
    if (CheckPointInLine(lineList[i], cur.a) &&
        CheckPointInLine(lineList[i], cur.b)) {
      return true;
    }
  }
  return false;
}

int main() {
  vector<Point> pointList;
  // 将所有点记入pointList中
  for (int i = 0; i < 20; i++) {
    for (int j = 0; j < 21; j++) { 
      pointList.push_back(Point(i, j));
    }
  }

  // 尝试任意两点的组合组成的直线，如果直线没出现过则记录下来，否则跳过
  int ans = 0;
  for (unsigned int i = 0; i < pointList.size(); i++) {
    for (unsigned int j = i + 1; j < pointList.size(); j++) {
      Line curLine = Line(pointList[i], pointList[j]);
      if (!CheckLineRepeat(curLine)) {
        ans++;
        lineList.push_back(curLine);
      }
    }
  }
  printf("ans = %d\n", ans);
  return 0;
}

 试题D：

问题描述

        小蓝有一个超大的仓库，可以摆放很多货物
现在，小蓝有n 箱货物要摆放在仓库，每箱货物都是规则的正方体。小蓝规定了长、宽、高三个互相垂直的方向，每箱货物的边都必须严格平行于长、宽、高。
小蓝希望所有的货物最终摆成一个大的立方体。即在长、宽、高的方向上分别堆L、W、H的货物，满足n=LxWxH。
给定n，请问有多少种堆放货物的方案满足要求
例如，当n=4时，有以下6种方案:1x1x4、1x2x2、1x4x1、2x1x2、2X2X1、4X1x1。
请问，当n=2021041820210418(注意有 16位数字)时，总共有多少种方案?

知识点涉及：质因数分解

答案：2430

解析：

代码：

#include <bits/stdc++.h>
using namespace std;

vector<long long int> primeNum, primeVal;
// 将x质因数分解
void CalaPrime(long long int x) {
  printf("%lld = ", x);
  for (long long int i = 2; i * i <= x; i++) {
    if (x % i == 0) {
      int num = 0;
      while (x % i == 0) {
        x /= i;
        num++;
      }
      primeNum.push_back(num);
      primeVal.push_back(i);
    }
  }
  if (x > 1) {
    primeNum.push_back(1);
    primeVal.push_back(x);
  }

  for (unsigned int i = 0; i < primeNum.size(); i++) {
    if (i != 0) {
      printf("  *  ");
    }
    printf("\n(%lld ^ %lld)", primeVal[i], primeNum[i]);
  }
  printf("\n");
}

int main() {
  CalaPrime(2021041820210418);

  long long int ans = 0;
  ans = 3 * 3 * 3 * 3 * 3;
  ans *= 10;

  printf("ans = %lld\n", ans);
  return 0;
}

 试题E：

问题描述

         小蓝学习了最短路径之后特别高兴，他定义了一个特别的图，希望找到图中的最短路径。
小蓝的图由2021个结点组成，依次编号1至2021。
对于两个不同的结点ab，如果a和b的差的绝对值大于21，则两个结点之间没有边相连:如果a和b的差的绝对值小于等于21，则两个点之间有一条长度为a和b的最小公倍数的无向边相连。
例如:结点1和结点23之间没有边相连:结点3和结点24 之间有一条无向边，长度为24:结点15 和结点25 之间有一条无向边，长度为75。
请计算，结点1和结点 2021之间的最短路径长度是多少。

知识点涉及：图论，最短路，最大公约数

答案：10266837

解析：

       

代码：

#include <bits/stdc++.h>
using namespace std;

const int maxn = 2021;

vector<int> u[maxn + 52];
vector<int> v[maxn + 52];
int disDijk[maxn + 52];
int disFloyd[maxn + 52][maxn + 52];
bool vis[maxn + 52];

// 初始化建图，u[i][j]表示i的第j条出边编号，v[i][j]表示i的第j条边的长度，也就是i和u[i][j]的距离
void InitGroup() {
  for (int i = 1; i <= maxn; i++) {
    for (int j = i + 1; j <= maxn; j++) {
      if (j - i <= 21) {
        u[i].push_back(j);
        v[i].push_back(i * j / __gcd(i, j));
        u[j].push_back(i);
        v[j].push_back(i * j / __gcd(i, j));
      }
    }
  }
}

// floyd算法计算最短路，disFloyd[i][j] 表示i到j的最短距离
void Floyd() {
  // 初始化disFloyd为一个较大值
  memset(disFloyd, 0x3f, sizeof(disFloyd));
  for (unsigned int i = 1; i <= maxn; i++) {
    for (unsigned int j = 0; j < v[i].size(); j++) {
      disFloyd[i][u[i][j]] = v[i][j];
      disFloyd[u[i][j]][i] = v[i][j];
    }
  }

  // 执行floyd算法
  for (int k = 1; k <= maxn; k++) {
    for (int i = 1; i <= maxn; i++) {
      for (int j = 1; j <= maxn; j++) {
        disFloyd[i][j] = disFloyd[j][i] = min(disFloyd[i][j], disFloyd[i][k] + disFloyd[k][j]);
      }
    }
  }
  printf("floyd ans = %d\n", disFloyd[1][maxn]);
}

// Dijkstra算法计算最短路，disDijk[i]表示i距离结点1的最短距离
void Dijkstra() {
  memset(disDijk, 0x3f, sizeof(disDijk));
  memset(vis, 0, sizeof(vis));

  disDijk[1] = 0;

  for (int i = 1; i <= maxn; i++) {
    int curMin = 0x3f3f3f3f;
    int curIndex = -1;
    for (int j = 1; j <= maxn; j++) {
      if (vis[j]) {
        continue;
      }
      if (curMin > disDijk[j] || curIndex == -1) {
        curMin = disDijk[j];
        curIndex = j;
      }
    }
    vis[curIndex] = true;

    for (unsigned int j = 0; j < u[curIndex].size(); j++) {
      int t = u[curIndex][j], val = v[curIndex][j];
      disDijk[t] = min(disDijk[t], disDijk[curIndex] + val);
    }
  }
  printf("Dijkstra ans = %d  vis = %d\n", disDijk[2021], vis[2021]);
}

int main() {
  InitGroup();
  Floyd();
  Dijkstra();

  return 0;
}

 试题F：

问题描述

          

知识点涉及：取模，时间计算，格式化输出

解析：

        注意题目中给定的是毫秒，利用整除和取模就可以完成计算。具体细节可以参照代码中的注释。

代码：

#include <bits/stdc++.h>
using namespace std;

int main() {

  long long int dayMs = 24 * 60 * 60 * 1000; //一天包含多少毫秒
  long long int n;
  scanf("%lld", &n);

  // 扣除整天的描述之后，得到最后一天剩下了多少毫秒
  n = n % dayMs;
  // 忽略毫秒，得到还剩多少秒
  n = n / 1000;

  // 一小时3600秒，走过了多少个完整的3600秒就代表当前小时数是多少
  int hour = n / (3600);

  // 扣除整小时之后剩下的秒数，可以走过多少个完整的60秒就代表当前分钟数是多少
  int minutes = (n - hour * 3600) / 60;

  // 走完全部的完整60秒之后剩下的秒数就是秒数
  int second = n % 60;

  printf("%02d:%02d:%02d\n", hour, minutes, second);
}

 试题G：

问题描述

          

知识点涉及：动态规划，类背包问题

解析：

       

代码：

#include <bits/stdc++.h>
using namespace std;

const int offset = 100052; // 为处理负数情况引入的偏移量
const int maxn = 100052 + offset;
int n, vis[2][maxn], a[2000];

int main() {
  scanf("%d", &n);
  for (int i = 0; i < n; i++) {
    scanf("%d", &a[i]);
  }

  memset(vis, 0, sizeof(vis));
  vis[0][offset] = 1;
  int pre = 0, cur = 1;

  // 三种情况分别是，不选择a[i]，选择a[i]，选择-a[i]
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < maxn; j++) {
      vis[cur][j] = max(vis[cur][j], vis[pre][j]);
      if (j - a[i] >= 0) {
        vis[cur][j] = max(vis[pre][j - a[i]], vis[cur][j]);
      }
      if (j + a[i] < maxn) {
        vis[cur][j] = max(vis[pre][j + a[i]], vis[cur][j]);
      }
    }
    swap(pre, cur); // 滚动循环利用数组的pre行和cur行
  }

  // 注意要从offset+1开始，因为能称出来的重量不应该是负数
  int ans = 0;
  for (int i = offset + 1; i < maxn; i++) {
    if (vis[pre][i]) {
      ans++;
    }
  }
  printf("%d", ans);
  return 0;
}

 试题H：

问题描述

        

知识点涉及：二分，组合数计算，打表

代码：

#include <bits/stdc++.h>
using namespace std;

// 打印杨辉三角前x行，帮助直观感受
void Print(int x) {
  long long int c[100][100];

  for (int i = 1; i <= x; i++) {
    c[i][0] = 1;
    printf("%lld\t", c[i][0]);
    for (int j = 1; j < i; j++) {
      c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
      printf("%lld\t", c[i][j]);
    }
    printf("\n");
  }
}

// 二分方法
long long int n;
long long int C(long long int a, long long int b) {
  long long int ret = 1;
  for (long long int i = a, j = 1; j <= b; i--, j++) {
    ret = ret * i / j;
    if (ret > n) {
      return n + 1;
    }
  }
  return ret;
}

long long int GetAns(int col) {
  long long int l = col, r = max(n, (long long int)col);
  while (l < r) {
    long long int mid = (l + r) / 2;
    if (C(mid, col) >= n)
      r = mid;
    else
      l = mid + 1;
  }

  if (C(r, col) != n) { // 没有出现则返回出现位置无限大
    return 4e18;
  } else {
    return r * (r + 1) / 2 + col + 1;
  }
}

int main() {
  scanf("%lld", &n);

  long long int ans = 4e18;
  for (int i = 0; i < 20; i++) { // 枚举前20列，记录最早出现位置
    long long int cur = GetAns(i);
    ans = min(ans, cur);
  }

  printf("%lld\n", ans);
  return 0;
}

 试题I：

问题描述

          

知识点涉及：贪心，线段树，排序

解析：

       此题完全通过较为困难，此处给出简单版本使用sort函数代码。可以考虑，对于连续的0操作或者1操作，只需要执行覆盖数组长度最长的操作即可，这样就可以一定程度上减少操作次数，从而提高程序运行效率。

代码：

#include <bits/stdc++.h>
using namespace std;

const int maxn = 100052;
int a[maxn];
bool cmp(int x, int y) { return x > y; }

struct Oper {
  int pos, op;
};

int main() {
  int n, m;
  scanf("%d%d", &n, &m);
  for (int i = 0; i < n; i++) {
    a[i] = i + 1;
  }

  // 读取操作列表
  vector<Oper> opList;
  for (int i = 0; i < m; i++) {
    Oper temp;
    scanf("%d%d", &temp.op, &temp.pos);
    opList.push_back(temp);
  }

  // 操作去重转变成01交错的操作序列
  vector<Oper> newList;
  Oper curOp = opList[0];
  for (unsigned int i = 0; i < opList.size(); i++) {
    if (curOp.op != opList[i].op) { // 操作01转换则保存当前等价操作并重新记录
      newList.push_back(curOp);
      curOp = opList[i];
      continue;
    }
    if (opList[i].op == 0 && opList[i].pos > curOp.pos) {
      curOp = opList[i];
    }
    if (opList[i].op == 1 && opList[i].pos < curOp.pos) {
      curOp = opList[i];
    }
  }
  newList.push_back(curOp);

  // 模拟执行操作
  for (unsigned int i = 0; i < newList.size(); i++) {
    if (newList[i].op == 0) {
      sort(a, a + newList[i].pos, cmp);
    } else {
      sort(a + newList[i].pos - 1, a + n);
    }
  }

  // 打印结果
  for (int i = 0; i < n; i++) {
    if (i != 0) {
      printf(" ");
    }
    printf("%d", a[i]);
  }

  return 0;
}

 试题J：

问题描述

          

知识点涉及：动态规划，取模

解析：

       

代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 5052;
const long long int MOD = 1e9 + 7;

int dp[maxn][maxn];
bool vis[maxn][maxn];
char str[maxn];
int n;

long long int mod(long long int x) { return x % MOD; }

long long int GetAns() {
  memset(dp, 0, sizeof dp);
  memset(vis, 0, sizeof vis);
  dp[0][0] = 1;
  vis[0][0] = true;

  for (int i = 1; i <= n; i++) {
    if (str[i - 1] == '(') {
      for (int j = 1; j <= n; j++) {
        dp[i][j] = dp[i - 1][j - 1];
        vis[i][j] = vis[i - 1][j - 1];
      }
    } else {
      dp[i][0] = mod(dp[i - 1][0] + dp[i - 1][1]);
      vis[i][0] = vis[i-1][0] | vis[i-1][1];
      for (int j = 1; j <= n; j++) {
        dp[i][j] = mod(dp[i - 1][j + 1] + dp[i][j - 1]);
        vis[i][j] = vis[i - 1][j + 1] | vis[i][j - 1];
      }
    }
  }
  for (int i = 0; i <= n; i++) {
    if (vis[n][i] != 0) {
      return dp[n][i];
    }
  }
  return -1;
}
int main() {
  scanf("%s", str);
  n = strlen(str);

  long long int ansL = GetAns();

  reverse(str, str + n);
  for (int i = 0; i < n; i++) {
    if (str[i] == ')') {
      str[i] = '(';
    } else {
      str[i] = ')';
    }
  }
  long long int ansR = GetAns();

  printf("%lld\n", mod(ansL * ansR));
  return 0;
}

标签
#蓝桥杯 #c++
本内容遵循 CC 4.0 BY-SA 版权协议
原文链接：https://mp.weixin.qq.com/s/7ddFI7d7lztW26i6tgWCLA
2021.5.9蓝桥杯C/C++ B组第二场（个人见解） 第J道实在不会，抛砖引玉希望能够得到最后一道题的解析，第一次写，内容仅供参考 阅读详情

相关推荐

2021第十二届蓝桥杯大赛软件赛省赛第二场C/C++B组题目加题解

我是小白！！！很白的那种，小白白哦！！！ 今年的蓝桥杯第二场题目对于我这个小白白还算友好，难的不会，起码简单的会一点。我把我把昨天考试的自己的解题结果贴一下（自己的解法！！！不是官方答案），有问题大佬要指正哟！！！ 题目链接：https://pan.baidu.com/s/1O146R_4-S5VEd_lsXwwpRA 提取码：fakl 我们来进入正题 试题A【求余】 看到第一个题惊呆我了，直接口算就完事。 答案：1 当然也可以用代码实现 #include<stdio.h> int mai

m0_53521757的博客 3384

13到21年蓝桥杯真题及解析

2013年第四届蓝桥杯省赛试题详解 第四届蓝桥杯C/C++ B组试题解析 2014年第五届蓝桥杯省赛试题详解 第五届蓝桥杯C/C++ B组试题解析 2015年第六届蓝桥杯省赛试题详解 第六届蓝桥杯C/C++ B组试题解析 2016年第七届蓝桥杯省赛试题详解 第七届蓝桥杯C/C++ B组试题解析 2017年第八届蓝桥杯省赛试题详解 第八届蓝桥杯C/C++ B组试题解析 2018年第九届蓝桥杯省赛试题详解 第九届蓝桥杯C/C++ B组试题解析 2019年第十届蓝桥杯省赛试题详解 第十届蓝桥杯C/C++ B组试题

Pluto1219的博客 1667

蓝桥杯B组省赛历届真题及解析C/C++

蓝桥杯B组省赛历届真题及解析C/C++ 目录蓝桥杯B组省赛历届真题及解析C/C++前言跳转目录ps 前言 网上这部分内容好像比较欠缺，此系列文章最主要用于分享题目（找个真题真不容易），其次用于记录学习以及分析学习心得。 跳转目录 2012年第三届C/C++ B组蓝桥杯省赛真题 2013年第四届C/C++ B组蓝桥杯省赛真题 2014年第五届C/C++ B组蓝桥杯省赛真题 2015年第六届C/C++ B组蓝桥杯省赛真题 2016年第七届C/C++ B组蓝桥杯省赛真题 2017年第八届C/C++ B组蓝

qq_52134928的博客 1万+

蓝桥杯-完美的代价(C++详细解释版)

题目 题目描述 回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。 交换的定义是：交换两个相邻的字符例如mamad 第一次交换 ad : mamda 第二次交换 md : madma 第三次交换 ma : madam (回文！完美！) 输入 第一行是一个整数N，表示接下来的字符串的长度(N < = 8000) 第二行是一个字符串，长度为N.只包含小写字母

夏日 の blog 4440

蓝桥杯：空间

简单的进制转换，1GB = 1024MB = 1024^2KB = 1024^3B = 1024^3*8bit 一个二进制数占1bit，所以一个32位的二进制数占4B的空间，换算一下即可。 #include <iostream> using namespace std; int main() { // 请在此输入您的代码 // 32位二进制数就是4B,256MB=256*1024KB=256*1024*1024B, // 结果就是256*1024*1024%4 prin..

m0_52510770的博客 1797

第十二届蓝桥杯 2021年4月 省赛 第一场 C/C++ B组 题解

本题解为非官方题解

weifeng2356的博客 2万+

2021年蓝桥杯c++b组解析(个人)

2021年蓝桥杯c/c++ b组题目解析。5道填空5道编程，究竟是什么样的难度？走进博客，带你切身体验蓝桥杯的难度！同时临近竞赛，也是回顾和反思的时候，进行更好地学习！

JacinLee的博客 9315

小蓝准备用 256MB 的内存空间开一个数组，数组的每个元素都是 32位 二进制整数， 如果不考虑程序占用的空间和维护内存需要的辅助空间， 请问 256MB 的空间可以存储多少个 3232 位二进

小蓝准备用 256MB 的内存空间开一个数组，数组的每个元素都是 32位 二进制整数， 如果不考虑程序占用的空间和维护内存需要的辅助空间， 请问 256MB 的空间可以存储多少个 3232 位二进制整数？

m0_64071068的博客 1325

2021第十二届蓝桥杯大赛软件赛省赛C/C++B组（第一场）参考答案与解析

这次蓝桥杯准备了几个月，考得又⑧太行。。。。考试前一天发现自己不会迪杰斯特拉算法只会弗洛伊德算法，考试当天第五题弗洛伊德算法超时了。。。。当场气死。（说个笑话：暴力杯暴力会超时了）

Left_Zzzz的博客 3570

2021第十二届4月蓝桥杯大赛软件类B组C/C++省赛题解（已更新至第I题）

2021第十二届4月蓝桥杯大赛软件类B组C/C++省赛目录试题 A：空间（结果填空）试题 B：卡片（结果填空）试题 C：直线（结果填空）试题 D：货物摆放（结果填空）试题 E：路径（结果填空）试题 F：时间显示（程序设计）试题 G：砝码称重（结果填空）试题 H：杨辉三角形（程序设计）试题 I：双向排序（程序设计）试题 J：括号序列（程序设计） 试题 A：空间（结果填空） 题意： 做法： 答案： 试题 B：卡片（结果填空） 题意： 做法： 代码： 答案： 试题 C：直线（结果填空） 题意： 做法

小白菜的博客 4147

2021第十二届蓝桥杯C/C++B组省赛 第一场 部分题目总结

试题A: 思路：考计算机基础知识 bit:位，又名比特，缩写是b,是计算机中最小的数据单位，其实就是0,1这样的二进制位 Byte:字节，缩写是B,是计算机文件大小的基本计算单位，一个字符是1Byte,如果是汉字，则是2Byte 1Byte=8bit 1Byte=8bit(1B=8b) 1个字节=8位,即一个字节由8个二进制位构成 1KB=1024Byte 1MB=1024KB 1GB=1024MB 1TB=1024GB 所以本题： 1个32位二进制数占4个字节 25610241024/4=6710886

qq_51817638的博客 1481

蓝桥杯大赛软件赛省赛，C/C++大学B组，改革后2019-2021真题知识点分类

1、蓝桥杯 比赛时长： 四个小时 比赛规则： 蓝桥杯比赛跟天梯赛、ACM还不太一样，比赛中提交的答案并没有反馈机制，也就是说你提交了答案以后，自己并不知道是对是错，就像考试一样，只有交了卷，成绩下来以后才能知道自己的奖项。 满分150 01-05答案提交共45分，分值分别是5，5，10，10，15 06-10为程序提交共105分，分值分别是15，20，20，25，25 T6-T10开放补题 提交链接： https://lx.lanqiao.cn/problemset.page https://www.lan

小哈里的博客 4328

2021 第十二届蓝桥杯大赛软件赛决赛, 国赛，C/C++ 大学B组题解

2021 第十二届蓝桥杯大赛软件赛决赛, 国赛，C/C++ 大学B组题解 文章目录 第1题 —— 带宽 （5分） 第2题 —— 纯质数 （5分） 第3题 —— 完全日期 （10分） 第4题 —— 最小权值 （10分） 第5题 —— 大写 （15分） 第6题 —— 123 （15分） 第7题 —— 异或变换 （20分） 第8题 —— 二进制问题 （20分） 第9题 —— 翻转括号序列 （25分） 第10题 —— 异或三角 （25分）

小哈里的博客 2160

第十二届蓝桥杯 2021年省赛真题 (C/C++ 大学B组) 第二场

蓝桥杯 2021年省赛真题 (C/C++ 大学C组 ）#A 求余#B 双阶乘#C 格点朴素解法倍数法#D 整数分解归纳法数理分析#E 城邦#F 特殊年份#G 小平方#H 完全平方数#I 负载均衡#J 国际象棋状压 DP 解析移步对应 Java组 的题解。 #A 求余 本题总分：555 分 问题描述   在 C/C\mathrm{C/C}C/C++/Java/Python\mathrm{/Java/Python}/Java/Python 等语言中，使用 %\%% 表示求余，请问 2021%202021\

NOW I GOT ONE WAY 2218

【***蓝桥杯国赛部分真题及解析汇总***】

(67条消息) 2018蓝桥杯国赛C/C++B组真题_Micmic33的博客-CSDN博客(67条消息) 2018蓝桥杯国赛C/C++B组真题_Micmic33的博客-CSDN博客(67条消息) 2019蓝桥杯国赛C/C++B组真题_Micmic33的博客-CSDN博客 (67条消息) 2020蓝桥杯国赛C/C++B组真题_Micmic33的博客-CSDN博客_蓝桥杯c++国赛真题 (67条消息) 2021蓝桥杯国赛C/C++B组真题_Micmic33的博客-CSDN博客_蓝桥杯c++国赛真题.......

weixin_53459056的博客 689

2021年（12届）蓝桥杯CB组个人题解

我们首先发现，对每个数，他会顺序排在画圈的这一斜列，从 1 到 n，而他有大概率（超过一半），会是在这一列第一次出现，那我们直接把这个位置当作他出现的第一个位置，就大概率能蒙对他的位置，然后打表把1-10的位置先写出来， 如果小于10，直接输出就行，先拿下20的分数，遍历每个x1，x2，y1，y2， 将 公式 kx + b = y 放入到set里自动去重，最后输出set的size就行。对a进行，x，y，z三重循环，找到a[x]*a[y]*a[x] == n，ans+1；分解质因数后放到a里面，

weiweiwei0011646的博客 328

2021第十二届蓝桥杯大赛软件赛省赛C/C++ 大学 B 组

记录刷题的过程、感悟、题解。 希望能帮到，那些与我一同前行的，来自远方的朋友😉

2302_80067378的博客 3535

2020蓝桥杯省赛C/C++B组(第一场)真题及解析

本博客是2020蓝桥杯省赛C/C++B组（第一场）真题及详解

阿怪的博客 2万+
上一篇： 深度学习入门（二）
点赞 0
评论 1
书签 书签 8
我爱炼丹
我爱炼丹
博客等级 码龄5年 3粉丝 3原创
+ 关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值