1. Toy模板网首页
  2. > Toy博客

2023第十四届蓝桥杯C/C++B组省赛题解

10月前 作者：trudbot 分类：Toy博客 阅读(41) 违法举报

这篇具有很好参考价值的文章主要介绍了2023第十四届蓝桥杯C/C++B组省赛题解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

2023蓝桥C/C++B组省赛

试题A: 日期统计

题目描述

【问题描述】
小蓝现在有一个长度为100 的数组，数组中的每个元素的值都在0 到9 的范围之内。数组中的元素从左至右如下所示：

5 6 8 6 9 1 6 1 2 4 9 1 9 8 2 3 6 4 7 7 5 9 5 0 3 8 7 5 8 1 5 8 6 1 8 3 0 3 7 9 2 7 0 5 8 8 5 7 0 9 9 1 9 4 4 6 8 6 3 3 8 5 1 6 3 4 6 7 0 7 8 2 7 6 8 9 5 6 5 6 1 4 0 1 0 0 9 4 8 0 9 1 2 8 5 0 2 5 3 3

现在他想要从这个数组中寻找一些满足以下条件的子序列：

  1. 子序列的长度为8；

  2. 这个子序列可以按照下标顺序组成一个yyyymmdd 格式的日期，并且
    要求这个日期是2023 年中的某一天的日期，例如20230902，20231223。yyyy 表示年份，mm 表示月份，dd 表示天数，当月份或者天数的长度只有一位时需要一个前导零补充。

请你帮小蓝计算下按上述条件一共能找到多少个不同的2023 年的日期。
对于相同的日期你只需要统计一次即可。

枚举

用八重循环直接枚举每一位数字， 题目中的日期序列有很多限制， 如前四位必须是2023， 又比如月份只能以0或1开头等等。利用这些限制能大大降低运行时间， 实测只要限制了前四位， 基本是瞬间跑出结果。

注意需要用哈希表去重。

参考代码

//
// Created by trudbot on 2023/4/9.
//

#include <bits/stdc++.h>
using namespace std;
int days[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
set<int> res;

void check(int m, int d) {
    if (m < 1 || m > 12 || d < 1 || d > days[m]) return;
    res.insert(m * 100 + d);
}

int main () {
    int ns[100];
    for (int & n : ns) cin >> n;
    for (int a = 0; a < 100; a ++) {
        if (ns[a] != 2) continue;
        for (int b = a + 1; b < 100; b ++) {
            if (ns[b] != 0) continue;
            for (int c = b + 1; c < 100; c ++) {
                if (ns[c] != 2) continue;
                for (int d = c + 1; d < 100; d ++) {
                    if (ns[d] != 3) continue;

                    for (int i = d + 1; i < 100; i ++)
                        for (int j = i + 1; j < 100; j ++)
                            for (int k = j + 1; k < 100; k ++)
                                for (int l = k + 1; l < 100; l ++)
                                    check(ns[i] * 10 + ns[j], ns[k] * 10 + ns[l]);
                }
            }
        }
    }
    cout << res.size() << endl;
    return 0;
}
//in: 5 6 8 6 9 1 6 1 2 4 9 1 9 8 2 3 6 4 7 7 5 9 5 0 3 8 7 5 8 1 5 8 6 1 8 3 0 3 7 9 2
//7 0 5 8 8 5 7 0 9 9 1 9 4 4 6 8 6 3 3 8 5 1 6 3 4 6 7 0 7 8 2 7 6 8 9 5 6 5 6 1 4 0 1
//0 0 9 4 8 0 9 1 2 8 5 0 2 5 3 3
//out: 235

试题B: 01 串的熵

题目描述

对于一个长度为n 的01 串 S = x 1 x 2 x 3 . . . x n S = x_1x_2x_3...x_n S=x1​x2​x3​...xn​，香农信息熵的定义为 H ( S ) = − ∑ 1 n p ( x i ) log ⁡ 2 ( p ( x i ) ) H(S ) = −\sum^n_1p(x_i) \log_2(p(x_i)) H(S)=−∑1n​p(xi​)log2​(p(xi​))，其中 p ( 0 ) , p ( 1 ) p(0),p(1) p(0),p(1) 表示在这个01 串中0 和1 出现的占比。

比如，对于S = 100 来说，信息熵 H ( S ) = − 1 3 log ⁡ 2 ( 1 3 ) − 2 3 log ⁡ 2 ( 2 3 ) − 2 3 log ⁡ 2 ( 2 3 ) = 1.3083 H(S ) = −\frac13 \log_2( \frac13 ) − \frac23 \log_2( \frac23 ) − \frac23 \log_2( \frac23 )=1.3083 H(S)=−31​log2​(31​)−32​log2​(32​)−32​log2​(32​)=1.3083。对于一个长度为23333333 的01 串，如果其信息熵为11625907.5798，且0 出现次数比1 少，那么这个01 串中0 出现了多少次？

枚举|模拟

设01字符串S长度为n, 0的个数为x。

则 p ( 0 ) = x n , p ( 1 ) = n − x n p(0) = \frac xn, p(1) = \frac{n-x}{n} p(0)=nx​,p(1)=nn−x​.

H ( S ) = − ∑ 1 n p ( x i ) log ⁡ 2 ( p ( x i ) ) = − ( x p ( 0 ) log ⁡ 2 ( p ( 0 ) ) + ( n − x ) p ( 1 ) log ⁡ 2 ( p ( 1 ) ) ) H(S ) =−\sum^n_1p(x_i) \log_2(p(x_i)) = -(xp(0)\log_2(p(0)) + (n-x)p(1)\log_2(p(1))) H(S)=−∑1n​p(xi​)log2​(p(xi​))=−(xp(0)log2​(p(0))+(n−x)p(1)log2​(p(1)))

在已知n, x时， 计算H是 O ( 1 ) O(1) O(1)的， 所以只需要枚举x即可。

参考代码

//
// Created by trudbot on 2023/4/9.
//

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll H = 116259075798;
const ll N = 23333333;

bool check(ll x) {
    double p0 = x * 1.0 / N, p1 = 1 - p0;
    ll h = 10000ll * (x * p0 * log2(p0) + (N - x) * p1 * log2(p1));
    return h + H == 0;
}

int main () {
    for (int x = 1; x <= N / 2; x ++) {
        if (check(x)) cout << x << endl;
    }
    return 0;
}
//out: 11027421

试题C: 冶炼金属

题意描述

小蓝有一个神奇的炉子用于将普通金属O 冶炼成为一种特殊金属X。这个炉子有一个称作转换率的属性V，V 是一个正整数，这意味着消耗V 个普通金属O 恰好可以冶炼出一个特殊金属X，当普通金属O 的数目不足V 时，无法继续冶炼。

现在给出了N 条冶炼记录，每条记录中包含两个整数A 和B，这表示本次投入了A 个普通金属O，最终冶炼出了B 个特殊金属X。每条记录都是独立的，这意味着上一次没消耗完的普通金属O 不会累加到下一次的冶炼当中。
根据这N 条冶炼记录，请你推测出转换率V 的最小值和最大值分别可能是多少，题目保证评测数据不存在无解的情况。

取交集

对于每一条记录， 都可以求出转换率V的一个取值范围。 V必须满足所有记录求出的取值范围， 所以只需要对N个区间求交集即可, 也就是右边界取所有右边界的最小值， 左边界取所有左边界的最大值。。

参考代码

//
// Created by trudbot on 2023/4/9.
//

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

int main () {
    int n; cin >> n;
    int mn = -1, mx = 1e9;
    while (n --) {
        int a, b; cin >> a >> b;
        int l = a / (b + 1) + 1, r = a / b;
        mn = max(mn, l), mx = min(mx, r);
    }
    cout << mn << " " << mx << endl;
    return 0;
}

试题D: 飞机降落

题意描述

N 架飞机准备降落到某个只有一条跑道的机场。其中第i 架飞机在 T i T_i Ti​ 时刻到达机场上空，到达时它的剩余油料还可以继续盘旋 D i D_i Di​ 个单位时间，即它最早可以于 T i T_i Ti​ 时刻开始降落，最晚可以于 T i + D i T_i + D_i Ti​+Di​ 时刻开始降落。降落过程需要 L i L_i Li​
个单位时间。

一架飞机降落完毕时，另一架飞机可以立即在同一时刻开始降落，但是不能在前一架飞机完成降落前开始降落。

请你判断N 架飞机是否可以全部安全降落。

DFS+剪枝， 懒得写

试题E: 接龙数列

题意描述

对于一个长度为K 的整数数列： A 1 , A 2 . . A K A_1,A_2..A_K A1​,A2​..AK​，我们称之为接龙数列当且仅当 A i A_i Ai​ 的首位数字恰好等于 A i − 1 A_{i−1} Ai−1​ 的末位数字(2 ≤ i ≤ K)。

例如 12 , 23 , 35 , 56 , 61 , 11 12,23,35,56,61,11 12,23,35,56,61,11 是接龙数列； 12 , 23 , 34 , 56 12,23,34,56 12,23,34,56 不是接龙数列，因为56的首位数字不等于34 的末位数字。所有长度为1 的整数数列都是接龙数列。

现在给定一个长度为N 的数列 A 1 , A 2 . . . A N A_1,A_2... A_N A1​,A2​...AN​，请你计算最少从中删除多少个数，可以使剩下的序列是接龙序列？

DP

要求使得数列变成接龙数列的最少删除个数， 相当于求该数列的最长接龙子数列的长度， 用总长度减去最长接龙长度即为最少删除个数。

定义 d p [ i ] [ j ] dp[i][j] dp[i][j]为前i个数中， 以数字j结尾的最长接龙数列的长度。

设第i个数的首位数字是a， 末位数字是b。 则 d p [ i ] dp[i] dp[i]中相对于 d p [ i − 1 ] dp[i-1] dp[i−1]可能发生变化的只有 d p [ i ] [ b ] dp[i][b] dp[i][b], 因为第i个数可能加到一个以a结尾的接龙数列中， 使得这个接龙数列长度加1并且结尾数字变成b.

所以状态转移方程为dp[i][b] = max(dp[i - 1][b], dp[i - 1][a] + 1)

参考代码

//
// Created by trudbot on 2023/4/9.
//

#include <bits/stdc++.h>
using namespace std;
int dp[10];

int main () {
    int n, mx = 0; cin >> n;
    for (int i = 0; i < n; i ++) {
        string s; cin >> s;
        int a = s[0] - '0', b = s.back() - '0';
        dp[b] = max(dp[b], dp[a] + 1), mx = max(mx, dp[b]);
    }
    cout << n - mx << endl;
    return 0;
}

试题F: 岛屿个数

题意描述

小蓝得到了一副大小为M × N 的格子地图，可以将其视作一个只包含字符‘0’（代表海水）和‘1’（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的‘1’ 相连接而形成。

在岛屿A 所占据的格子中，如果可以从中选出k 个不同的格子，使得他们的坐标能够组成一个这样的排列：( x 0 , y 0 x_0, y_0 x0​,y0​),( x 1 , y 1 x_1,y_1 x1​,y1​)… ( x k − 1 , y k − 1 x_{k−1}, y_{k−1} xk−1​,yk−1​)，其中( x ( i + 1 ) % k , y ( i + 1 ) % k x_{(i+1)}\%k,y_{(i+1)}\%k x(i+1)​%k,y(i+1)​%k) 是由( x i , y i x_i, y_i xi​,yi​) 通过上/下/左/右移动一次得来的(0 ≤ i ≤ k − 1)，此时这k 个格子就构成了一个“环”。如果另一个岛屿B 所占据的格子全部位于这个“环” 内部，此时我们将岛屿B 视作是岛屿A 的子岛屿。若B 是A 的子岛屿，C 又是B 的子岛屿，那C 也是A 的子岛屿。

请问这个地图上共有多少个岛屿？在进行统计时不需要统计子岛屿的数目。

dfs | 连通块

本题有两种类型的顶点, 一种是’海水’, 如果A海顶点在B海顶点的周围8个格子内, 那两个海顶点就算连通的.

另一个是’陆地’, 只有A在B的上下左右四个方格内, 两个陆地才是连通的.

地图外的方格我们全部视为海， 与地图外的海连通的海都视为外海， 可以发现， 接触到了外海的岛屿， 就一定不是其它岛屿的子岛。

所以在地图周围一圈， 我们增加一圈0作为外海， dfs遍历外海每一个方格， 若与外海方格相邻的岛屿未被遍历过，那么这就是一个新的岛屿， 再用一个dfs去遍历这个岛。

参考代码

//
// Created by trudbot on 2023/4/9.
//

#include <bits/stdc++.h>
using namespace std;
const int N = 60;
int g[N][N], n, m, res = 0;
bool st[N][N];
int dx[] = {0, 0, 1, -1},
    dy[] = {1, -1, 0, 0};

void dfs_1(int r, int c) {
    st[r][c] = true;
  	//四向连通
    for (int i = 0; i < 4; i ++) {
        int x = dx[i] + r, y = dy[i] + c;
        if (st[x][y] || g[x][y] == 0) continue;
        dfs_1(x, y);
    }
}

void dfs_0(int r, int c) {
    st[r][c] = true;
    //八向连通
    for (int i = -1; i <= 1; i ++)
        for (int j = -1; j <= 1; j ++) {
            int x = r + i, y = c + j;
            if (x < 0 || x > n + 1 || y < 0 || y > m + 1 || st[x][y]) continue;
            if (g[x][y] == 0) dfs_0(x, y);
            else dfs_1(x, y), res ++;
        }
}

int main () {
    int T; cin >> T;
    while (T --) {
        memset(g, 0, sizeof g);
        memset(st, false, sizeof st);
        cin >> n >> m; res = 0;
        for (int i = 1; i <= n; i ++)
            for (int j = 1; j <= m; j ++) {
                char c; cin >> c;
                g[i][j] = c - '0';
            }
        dfs_0(0, 0);//从一个外海方格开始dfs
        cout << res << endl;
    }
    return 0;
}

试题G: 子串简写

题意描述

程序猿圈子里正在流行一种很新的简写方法：对于一个字符串，只保留首尾字符，将首尾字符之间的所有字符用这部分的长度代替。例如internationalization简写成i18n，Kubernetes （注意连字符不是字符串的一部分）简
写成K8s, Lanqiao 简写成L5o 等。在本题中，我们规定长度大于等于K 的字符串都可以采用这种简写方法（长度小于K 的字符串不配使用这种简写）。

给定一个字符串S 和两个字符 c 1 c_1 c1​ 和 c 2 c_2 c2​，请你计算S 有多少个以 c 1 c_1 c1​ 开头 c 2 c_2 c2​ 结尾的子串可以采用这种简写？

前缀和

设p[i]为前i个字符中 c 1 c_1 c1​字符的个数, 则对于下标为j的 c 2 c_2 c2​字符, 以其结尾且可以简写的子串数量即为p[j - k + 1]

参考代码

//
// Created by trudbot on 2023/4/9.
//

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 5e5 + 10;
ll p[N], res;

int main () {
    int k; cin >> k;
    string s; char a, b; cin >> s >> a >> b;
    for (int i = 1; i <= s.size(); i ++) p[i] = p[i - 1] + (s[i - 1] == a);
    for (int i = k; i <= s.size(); i ++)
        if (s[i - 1] == b) res += p[i - k + 1];
    cout << res << endl;
    return 0;
}

试题H: 整数删除

题意描述

给定一个长度为N 的整数数列： A 1 , A 2 . . . A N A_1,A_2...A_N A1​,A2​...AN​。

你要重复以下操作K 次：每次选择数列中最小的整数（如果最小值不止一个，选择最靠前的），将其删除。并把与它相邻的整数加上被删除的数值。

输出K 次操作后的序列。

双向链表 | 最小堆

由于要进行大量的删除操作, 不难想到可以使用链表.

而本题需要动态的求最小值, 显然可以使用堆.

每次从堆中取出最小值的下标, 然后在链表中删除它.

但本题特殊点在于将其删除。并把与它相邻的整数加上被删除的数值, 所以会导致还在堆中的元素的权的变化.

我们可以注意到, 每次删除操作只会让一些元素变大, 而不会让元素变小. 也就是, 可能会让原本的最小值变成不是最小值.

因此我们取出堆中的最小值时, 需要将此元素的排序权和实际的值进行对比, 如果实际的值变大了, 则当前元素并不一定是最小值, 需要重新放回堆中.

参考代码

每次删除操作最多会让两个元素的值变化, 因此从堆中取出的次数是k的线性, 时间复杂度为 O ( n + k ) log ⁡ n O(n + k) \log n O(n+k)logn

//
// Created by trudbot on 2023/4/9.
//

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 5e5 + 10;
ll v[N], l[N], r[N];

void del(int x) {
    r[l[x]] = r[x], l[r[x]] = l[x];
    v[l[x]] += v[x], v[r[x]] += v[x];
}

int main () {
    int n, k; cin >> n >> k;
    r[0] = 1, l[n + 1] = n;
    priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>> h;
    for (int i = 1; i <= n; i ++)
        cin >> v[i], l[i] = i - 1, r[i] = i + 1, h.push({v[i], i});
    while (k --) {
        auto p = h.top(); h.pop();
        if (p.first != v[p.second]) h.push({v[p.second], p.second}), k ++;
        else del(p.second);
    }
    int head = r[0];
    while (head != n + 1) {
        cout << v[head]<< " ";
        head = r[head];
    }
    return 0;
}

试题I: 景区导游

题意描述

某景区一共有N 个景点，编号1 到N。景点之间共有N − 1 条双向的摆渡车线路相连，形成一棵树状结构。在景点之间往返只能通过这些摆渡车进行，需要花费一定的时间。

小明是这个景区的资深导游，他每天都要按固定顺序带客人游览其中K 个景点：A1; A2; : : : ; AK。今天由于时间原因，小明决定跳过其中一个景点，只带游客按顺序游览其中K − 1 个景点。具体来说，如果小明选择跳过Ai，那么他会按顺序带游客游览 A 1 ， A 2 . . . A i − 1 , A i + 1 , A K A_1，A_2... A_{i−1},A_{i+1},A_K A1​，A2​...Ai−1​,Ai+1​,AK​ (1 ≤ i ≤ K)。请你对任意一个Ai，计算如果跳过这个景点，小明需要花费多少时间在景点之间的摆渡车上？

带权LCA

要确定的一点是， 由于题中的图是一棵树， 所以对于任意两个顶点， 它们的最短路径就是它们的简单路径。

求树中两个结点的最短路径， 可以想到LCA。

设 d i s t [ u ] dist[u] dist[u]为u顶点到根结点的距离， 那么u和v的距离即为 d i s t [ u ] + d i s t [ v ] − 2 ∗ d i s t [ l c a ( u , v ) ] dist[u] + dist[v] - 2 * dist[lca(u, v)] dist[u]+dist[v]−2∗dist[lca(u,v)].

因此本题就是一道LCA的模板题， 使用倍增或者tarjan都是可以的, 具体的算法知识请自行去学习。

距离可能会爆int， 因此建议是所有整型都用long long， 避免麻烦。

参考代码

//
// Created by trudbot on 2023/4/10.
//
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
using ll = long long;
vector<pair<int, int>> g[N];
ll dep[N], f[N][30], dist[N];

void dfs(int u, int fa, ll d) {
    dep[u] = dep[fa] + 1, dist[u] = d, f[u][0] = fa;
    for (int i = 1; (1 << i) <= dep[u]; i ++) f[u][i] = f[f[u][i - 1]][i - 1];
    for (auto &p : g[u]) {
        if (p.first == fa) continue;
        dfs(p.first, u, d + p.second);
    }
}

int lca(int a, int b) {
    if (dep[a] < dep[b]) swap(a, b);
    for (int i = 20; i >= 0; i --) {
        if (dep[f[a][i]] >= dep[b]) a = f[a][i];
        if (a == b) return a;
    }
    for (int i = 20; i >= 0; i --) {
        if (f[a][i] != f[b][i]) a = f[a][i], b = f[b][i];
    }
    return f[a][0];
}

ll get(int a, int b) {
    return dist[a] + dist[b] - 2 * dist[lca(a, b)];
}

int main () {
    int n, k; cin >> n >> k;
    for (int i = 1; i < n; i ++) {
        int u, v, t; cin >> u >> v >> t;
        g[u].push_back({v, t}), g[v].push_back({u, t});
    }
    vector<int> a(k);
    for (auto &x : a) cin >> x;
    dfs(1, 0, 0);
    ll sum = 0;
    for (int i = 1; i < k; i ++) sum += get(a[i - 1], a[i]);
    for (int i = 0; i < k; i ++) {
        ll ans = sum;
        if (i != 0) ans -= get(a[i], a[i - 1]);
        if (i != k - 1) ans -= get(a[i], a[i + 1]);
        if (i != 0 && i != k - 1) ans += get(a[i - 1], a[i + 1]);
        cout << ans << " ";
    }
    return 0;
}

试题J: 砍树

题意描述

给定一棵由n 个结点组成的树以及m 个不重复的无序数对 ( a 1 , b 1 ) , ( a 2 , b 2 ) , . . . , ( a m , b m ) (a_1,b_1), (a_2,b_2),...,(a_m,b_m) (a1​,b1​),(a2​,b2​),...,(am​,bm​)，其中 a i a_i ai​ 互不相同， b i b_i bi​ 互不相同， a i ≠ b j a_i \neq b_j ai​=bj​(1 ≤ i, j ≤ m)。
小明想知道是否能够选择一条树上的边砍断，使得对于每个 ( a i , b i ) (a_i,b_i) (ai​,bi​) 满足 a i a_i ai​和 b i b_i bi​ 不连通，如果可以则输出应该断掉的边的编号（编号按输入顺序从1 开始），否则输出-1。

树上差分

同上题我们知道， 树中两个结点的简单路径是唯一的。

因此如果我们能找到一条边， 每组数对的两个结点的简单路径都要经过这条边， 那么就可以满足题意。

这时我们可以很简单的想到思路， 对于数对 ( a , b ) (a, b) (a,b)， 我们遍历a到b路径上的每一条边， 让其权值加一。

最后若存在权值为m的边， 那么就满足题意。

但这样做时间复杂度显然最坏是 O ( n m ) O(nm) O(nm)， 不达标。

这时候我们可以用到树上差分优化这一过程， 同理这里不会赘述它是什么， 请自行去学习相关知识。文章来源地址https://www.toymoban.com/news/detail-439738.html

参考代码

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 18;
vector<pair<int, int>> g[N];
int dep[N], f[N][20], cnt[N], w[N];

void init(int u, int fa) {
  dep[u] = dep[fa] + 1, f[u][0] = fa;
  for (int i = 1; (1 << i) <= dep[u]; i ++) f[u][i] = f[f[u][i - 1]][i - 1];
  for (auto &e : g[u]) {
    if (e.first != fa) init(e.first, u), w[e.first] = e.second;
  }
}

int lca(int a, int b) {
  if (dep[a] < dep[b]) swap(a, b);
  for (int i = M; i >= 0; i --) {
    if (dep[f[a][i]] >= dep[b]) a = f[a][i];
    if (a == b) return a;
  }
  for (int i = M; i >= 0; i --) {
    if (f[a][i] != f[b][i]) a = f[a][i], b = f[b][i];
  }
  return f[a][0];
}

void add(int a, int b) {
  int LCA = lca(a, b);
  cnt[a] ++, cnt[b] ++, cnt[LCA] -= 2;
}

void dfs(int u, int fa) {
  for (auto &e : g[u]) {
    if (e.first != fa) 
      dfs(e.first, u), cnt[u] += cnt[e.first];
  }
}

int main () {
  int n, m; cin >> n >> m;
  for (int i = 1; i < n; i ++) {
    int a, b; cin >> a >> b;
    g[a].push_back({b, i}), g[b].push_back({a, i});
  }
  init(1, 0);
  for (int i = 0; i < m; i ++) {
    int a, b; cin >> a >> b;
    add(a, b);
  }
  dfs(1, 0);
  int res = -1;
  for (int i = 1; i <= n; i ++) 
    if (cnt[i] == m && (w[i] > res)) res = w[i];
  cout << res << endl;
  return 0;
}

到了这里，关于2023第十四届蓝桥杯C/C++B组省赛题解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 第十四届蓝桥杯大赛青少年省赛C++组试题真题 2023年5月

    第十四届蓝桥杯大赛青少年省赛C++组试题真题 2023年5月

    一、选择题 第 1 题 单选题 C++中，bool类型的变量占用字节数为 ( )。 A. 1 B. 2 C. 3 D. 4 第 2 题 单选题 以下关于C++结构体的说法，正确的是 ( )。 A. 结构体中只能包含成员变量，不能包含成员函数 B. 结构体不能从另一个结构体继承 C. 结构体里面可以包含静态成员变量 D. 结构体里

    2024年02月15日
    浏览(53)

  • 第十四届蓝桥杯C/C++_大学B组省赛真题

    【考生须知】 考试开始后，选手首先下载题目，并使用考场现场公布的解压密码解压试题。 考试时间为 4 小时。考试期间选手可浏览自己已经提交的答案，被浏览的答案允许拷贝。时间截止后，将无法继续提交或浏览答案。 对同一题目，选手可多次提交答案，以最后一次提

    2023年04月11日
    浏览(50)

  • 2023年第十四届蓝桥杯大赛python组省赛真题（已更新完）

    本篇更新蓝桥杯省赛真题的后5道。 6.试题 F: 公因数匹配 时间限制: 10.0s 内存限制: 512.0MB 本题总分：15 分 【问题描述】 给定 n 个正整数 Ai，请找出两个数 i, j 使得 i j 且 Ai 和 Aj 存在大于 1 的 公因数。 如果存在多组 i, j，请输出 i 最小的那组。如果仍然存在多组 i, j，请输出

    2024年02月06日
    浏览(66)
  • 第十四届蓝桥杯省赛C++ B组（个人经历 + 题解）

    第十四届蓝桥杯省赛C++ B组（个人经历 + 题解）

    这是我第一次参加蓝桥杯的省赛，虽然没什么参赛经验，但是自己做了很多前几届蓝桥杯的题，不得不说，这一届蓝桥杯省赛的难度相较于之前而言还是比较大的。之前很流行蓝桥杯就是暴力杯的说法，但是随着参赛人数的增多，比赛认可度的提升，比赛题目的质量也明显越

    2024年02月03日
    浏览(44)
  • 第十四届蓝桥杯省赛c/c++大学B组题解

    第十四届蓝桥杯省赛c/c++大学B组题解

    个人答案，有错漏感谢指正哈 本题总分：5 分 【问题描述】   小蓝现在有一个长度为 100 的数组，数组中的每个元素的值都在 0 到 9 的范围之内。数组中的元素从左至右如下所示： 5 6 8 6 9 1 6 1 2 4 9 1 9 8 2 3 6 4 7 7 5 9 5 0 3 8 7 5 8 1 5 8 6 1 8 3 0 3 7 9 2 7 0 5 8 8 5 7 0 9 9 1 9 4 4 6 8 6 3

    2023年04月12日
    浏览(57)
  • 蓝桥杯第十四届省赛完整题解 C/C++ B组

    蓝桥杯第十四届省赛完整题解 C/C++ B组

    没有测评，不知道对不对，仅仅过样例而已 本题总分：5 分 【问题描述】 小蓝现在有一个长度为 100 的数组，数组中的每个元素的值都在 0 到 9 的 范围之内。数组中的元素从左至右如下所示： 5 6 8 6 9 1 6 1 2 4 9 1 9 8 2 3 6 4 7 7 5 9 5 0 3 8 7 5 8 1 5 8 6 1 8 3 0 3 7 9 2 7 0 5 8 8 5 7 0 9 9 1 9

    2023年04月13日
    浏览(51)

  • 第十四届蓝桥杯大赛软件赛省赛 Java 大学 B 组题解

    找规律，可以先手动模拟几次，会发现 随着n越大，零也越多，当n为40的时候刚好有9个0 所以到40项以后的末尾9个阶乘的和一定是不变的，可以用手算，也可以写程序 答案是，901327897 代码： Java中有十进制转化为二进制，十六进制，八进制的方法，暴力枚举一下即可。（因为

    2024年02月02日
    浏览(43)

  • 蓝桥杯2023年第十四届省赛真题-平方差--题解

    时间限制: 3s 内存限制: 320MB 提交: 2379 解决: 469 给定 L, R，问 L ≤ x ≤ R 中有多少个数 x 满足存在整数 y,z 使得 x = y2 − z2。 输入一行包含两个整数 L, R，用一个空格分隔。 输出一行包含一个整数满足题目给定条件的 x 的数量。 复制 复制 1 = 1^2 − 0^2 ； 3 = 2^2 − 1^2 ； 4 =

    2024年02月07日
    浏览(52)

  • 第十四届蓝桥杯大赛软件赛省赛-试题 B---01 串的熵 解题思路+完整代码

    欢迎访问个人网站来查看此文章：http://www.ghost-him.com/posts/db23c395/ 对于一个长度为 n 的 01 串 S = x 1 x 2 x 3 . . . x n S = x_{1} x_{2} x_{3} ... x_{n} S = x 1 ​ x 2 ​ x 3 ​ ... x n ​ ，香农信息熵的定义为 H ( S ) = − ∑ 1 n p ( x i ) l o g 2 ( p ( x i ) ) H(S ) = − {textstyle sum_{1}^{n}} p(x_{i})log_{2} (p

    2023年04月10日
    浏览(44)

  • 蓝桥杯2023年第十四届省赛真题-买瓜--C语言题解

    目录 蓝桥杯2023年第十四届省赛真题-买瓜 题目描述 输入格式 输出格式 样例输入 样例输出 提示 【思路解析】 【代码实现】 时间限制: 3s 内存限制: 320MB 提交: 796 解决: 69 小蓝正在一个瓜摊上买瓜。瓜摊上共有 n 个瓜，每个瓜的重量为 Ai 。 小蓝刀功了得，他可以把任何瓜

    2024年02月07日
    浏览(54)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包