第十二届蓝桥杯C++B组 A~H题题解

本次题解格式参考 墨羽魂韶

本文所用的试题:

第十二届蓝桥杯大赛软件赛省赛_CB.pdf

最后编辑时间

2021年4月29日 21:27:46

2022 年 4月 8号 15点13分

填空题答案速览

统一声明

如果不写默认带有常用头文件

如果不表明主函数默认表示在 void solve(){}

默认使用

using namespace std;

ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

using ll = long long;

填空题答案速览

67108864
3181
40257
2430
10266837

A. 空间

问题简述

256MB可以存放多少32位二进制整数?

1 Mb = 1024 Kb = 1024 * 1024 b

int = 4B (一个 int 占4比特)

注意用 long long

cout << 1ll * 256 * 1024 * 1024 * 8 / 32 << "\n";

B. 卡片

问题简述

用标有0~9且各有2021张的卡片可以拼到哪个数字

问题分析

直接按位统计, 不足退出即可, 特别注意, 退出循环的那个应该是正好无法达到的, 应该比那个少一

void solve() {

    for (int i = 0; i < 10; ++i) a[i] = 2021;

    int i = 1;

    while (true) {

        int tmp = i;

        while (tmp) {

            --a[tmp % 10], tmp /= 10;

        }

        bool f = true;

        for (int i = 0; f && i < 10; ++i)

            if (a[i] < 0) f = false;

        if (!f) break;

        i++;

    }

    cout << --i << '\n';

}

C. 直线

问题简述

给定平面上的 20*21 个整点, 问有不同的多少直线?

问题分析

结论而言就是比较K，B值，可以直接模拟，代码如下

const int N = 2e5 + 10;

struct Line {

    double k, b;

    bool operator<(const Line &t) const {

        if (k != t.k) return k < t.k;

        return b < t.b;

    }

} l[N];

void solve() {

    int cnt = 0;

    for (int x1 = 0; x1 < 20; ++x1)

        for (int y1 = 0; y1 < 21; ++y1)

            for (int x2 = 0; x2 < 20; ++x2)

                for (int y2 = 0; y2 < 21; ++y2) {

                    if (x1 != x2) {

                        double k = (double)(y2 - y1) / (x2 - x1);

                        double b = y1 - k * x1;

                        l[cnt++] = {k, b};

                    }

                }

    sort(l, l + cnt);

    int ans = 1;

    for (int i = 1; i < cnt; ++i)

        if (fabs(l[i].k - l[i - 1].k) > 1e-8 || fabs(l[i].b - l[i - 1].b) > 1e-8)

            ans++;

    cout << ans + 20 << '\n'; // 加上20条竖线

}

D. 货物摆放

问题简述

将 2021041820210418 可以分解为多少种 $A * B * C$的形式

问题分析

找到所有的因子，然后对因子进行暴力枚举

const ll N = 2021041820210418, mod = 1e3 + 7;

int P[mod], idx = 0;

void solve() {

    for (int i = 1; N / i >= i; ++i)

        if (N % i == 0) P[idx++] = i;

    ll cnt = 0;

    for (int i = 0; i < idx; ++i)

        for (int j = 0; j < idx; ++j)

            for (int k = 0; k < idx; ++k) {

                if (1ll * P[i] * P[j] * P[k] == N) ++cnt;

                if (N / P[i] != P[i] && P[i] == P[j] * P[k]) ++cnt;

                if (N / P[j] != P[j] && P[j] == P[i] * P[k]) ++cnt;

                if (N / P[k] != P[k] && P[k] == P[j] * P[i]) ++cnt;

            }

    cout << cnt << "\n";

}

E. 路径

问题简述

一个无向图, 2021个点, 标号为(1 ~ 2021), 如果两个点的差的绝对值<= 21, 则两点相通, 边长为两点的最大公倍数, 求起点1到2021的最小距离

问题分析

按题目建图, 跑一下SPFA（dijstra 等均可

void solve() {

    int n = 2021;

    for (int i = 0; i < 2022; ++i)

        for (int j = max(i - 21, 0), k = min(i + 21, 2021); j <= k; ++j)

            add(i, j, 1ll * i * j / gcd(i, j));

    cout << spfa() << '\n';// 赛后听说有人暴力跑 Floyd 也能出答案，但不建议

}

Update: Dijstra and DP

#include <bits/stdc++.h>

using namespace std;

using ll = long long;

const int N = 2025;

#define inf 0x3f3f3f3f

int e[N][N];

int d[N], dist[N];

bool vis[N];

int gcd(int a, int b) {return b == 0 ? a : gcd(b, a % b);}

int lcm(int a, int b) {return a / gcd(a, b) * b;}

int main() {

    ios::sync_with_stdio(false), cin.tie(nullptr);

    cout << fixed << setprecision(20);

    memset(e, inf, sizeof(e));

    for (int i = 1; i < N; i ++) {

        e[i][i] = 0;

        for (int j = i + 1; j < N; j ++) {

            int w = lcm(i, j);

            e[i][j] = e[j][i] = w;

        }

    }

    memset(d, inf, sizeof(d));

    memset(vis, false, sizeof(vis));

    d[1] = 0;

    for (int i = 1; i < N; i ++) {

        int x = 0 ;

        for (int j = 1; j < N; j ++) if (!vis[j] and d[j] < d[x]) x = j;

        vis[x] = 1;

        for (int j = max(1, x - 21); j <= min(N, x + 21); j ++) {

            d[j] = min(d[j], d[x] + e[x][j]);

        }

    }

    cout << d[2021] << "\n";

}

由于边的特殊性（边权为两数的最小公倍数，且两数的绝对值相差不超过21才连通），那么其实从1到某点的最短路径必然是递增的，证明：略（不会）

#include <bits/stdc++.h>

using namespace std;

using ll = long long;

using namespace std;

#define INF 0x3f3f3f3f

#define N 2025

int d[N];

int gcd(int a, int b) {return b == 0 ? a : gcd(b, a % b);}

int lcm(int a, int b) {return a / gcd(a, b) * b;}

int main() {

    ios::sync_with_stdio(false), cin.tie(nullptr);

    cout << fixed << setprecision(20);

    memset(d, INF, sizeof(d));

    d[1] = 0;

    for (int i = 1; i < N; i ++)

        for (int j = i + 1; j < N and j - i <= 21; j ++)

            d[j] = min(d[j], lcm(i, j) + d[i]);

    cout << d[2021] << "\n";

}

F. 时间显示

问题简述

给出一个整数, 表示1970年1月1日00:00开始经过的毫秒数, 输出对应的时分秒

问题分析

获取到对应的时间, 然后直接使用 printf输出即可

void solve() {

    ll time;

    cin >> time;

    int h = time / (1000 * 60 * 60) % 24;

    int m = time / (1000 * 60) % 60;

    int s = time / 1000 % 60;

    printf("%02d:%02d:%02d", h, m, s);

}

G. 砝码称重

问题简述

给出N个砝码, 重量分别为 $W_1,W_2,W_3,W_4,...,W_n$, 请问一共可以称出多少不同的重量

问题分析

假设有一个长度为1e6的数组, 表示可以称出的重量, 那么每多一个砝码(重量为k), 那么对于任何一个已经可以称出的重量( $i$ ), 可以组合得到 $i-k, k-i, i+k$ 这三种重量

我们只需要维护这个数组即可

const int N = 1e6 + 7;

int W[N]    = {1};

void solve() {

    int n, t;

    cin >> n;

    while (n--) {

        cin >> t;

        for (int i = 0; i < N; ++i) {

            // 为了节省空间, 用-1表示在大于i的, 1表示小于等于i的, 0表示无法称出的

            if (W[i] == 1) {

                // i-t的情况

                if (i > t) W[i - t] = 1;

                // t-i的情况

                if (t > i + i && W[t - i] != 1) W[t - i] = -1;

                if (t - i > 0 && W[t - i] != -1) W[t - i] = 1;

                // i+t的情况

                if (i + t < N && W[i + t] != 1) W[i + t] = -1;

            }

            if (W[i] == -1) W[i] = 1;

        }

    }

    int cnt = 0;

    for (int i = 1; i < N; ++i) cnt += W[i];

    cout << cnt << '\n';

}

H. 杨辉三角形

问题简述

给定一个数, 求出是在杨辉三角形的第几个数出现的

问题分析

比赛的时候没什么好的解法，随便找了下规律。用暴力能骗一些分

见注释

// Murabito-B 21/05/01

#include <bits/stdc++.h>

using namespace std;

using LL = long long;

int n;

/*

    组合数和杨辉三角：第i行第j列的数都是组合数C(i, j) （i，j从0开始）

        C(n, 1) = n --> 对应从左向右看斜着的第二列！ ---> 一定有解

    由于杨辉三角左右对称（C(a, b) == C(a, a-b)），又由于找第一次出现，因此一定在左边，右边可以直接删掉！

            1  ---> C(0, 0)

          1

        1   2  ---> C(2, 1)

      1   3                             ---> C(2n, n)

    1   4   6  ---> C(4, 2)

  1   5   10

1   6   15  20 ---> C(6, 3)

    n最大1e9，C(34, 17) > 1e9, C(32, 16) < 1e9，因此只要枚举前16个斜行即可！

    性质：

        1. 每一斜行从上到下递增

        2. 每一横行从中间到两边依次递减

    因此我们直接从中间对称轴倒序二分找起即可!

        C(r, k)对应的顺序值为：(r + 1) * r / 2 + k + 1

        二分的左右端点：l：2k，r：max(n, l)

            右端点一定不能比左端点小！

            特例：否则当n=1时，会出问题！

*/

// C(a, b) = a!/b!(a-b)! = a * (a-1) .. b个 / b!

LL C(int a, int b) {

    LL res = 1;

    for (int i = a, j = 1; j <= b; i--, j++) {

        res = res * i / j;

        // 大于n已无意义，且防止爆LL

        if (res > n) return res;

    }

    return res;

}

bool check(int k) {

    // 二分该斜行,找到大于等于该值的第一个数

    // 左边界2k，右边界为max(l, n)取二者最大即可！

    int l = 2 * k, r = max(n, l);

    while (l < r) {

        int mid = l + r >> 1;

        if (C(mid, k) >= n) r = mid;

        else

            l = mid + 1;

    }

    if (C(r, k) != n) return false;

    // C(r, k)的从0开始的顺序！

    cout << 1ll * (r + 1) * r / 2 + k + 1 << endl;

    return true;

}

int main() {

    cin >> n;

    // 从第16斜行枚举即可！

    for (int k = 16;; k--)

        if (check(k)) break;

    return 0;

}

I. 双向排序

问题简述

给定序列 $a_1,a_2,…,a_n=1,2,…,n,$ 对该序列进行 $m$次操作, 每次可能是对 [1, q]进行降序排列或者对[q, n] 进行升序排列

问题分析

没啥思路, 直接sort骗分了, 不过sort前判断了下当前是否有序, 有序直接调整了

暂未解决

J. 括号序列

问题简述

给定一个括号序列，要求尽可能少地添加若干括号使得括号序列变得合法

问题分析

分为两种特殊情况:

当左括号或右括号数量全为零, 此时是个卡特兰数
左括号与右括号相等, 不需要再插入括号

暂未解决