飞道的博客

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

205人阅读  评论(0)

本题解为非官方题解,可能存在包括但不限于下列问题

  • 答案错误
  • 时间复杂度太高,无法在规定时间内得出结果

填空题答案速览

  1. 67108864
  2. 3181
  3. 40257
  4. 2430
  5. 10266837

填空题

A 空间

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

题解
计算机基础
注意一字节等于八位
(因为考场电脑是32位系统,用 long long 会有奇奇怪怪的错误,而且python代码更短,所以用python写了)

print(256 * 1024 * 1024 * 8 // 32)
67108864

B 卡片

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

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

题解
模拟

#include <bits/stdc++.h>
using namespace std;
int a[10];
bool solve(int x) {
   
    while (x) {
   
        if (a[x % 10] > 0) {
   
            --a[x % 10];
        } else {
   
            return false;
        }
        x /= 10;
    }
    return true;
}
int main() {
   
    for (int i = 0; i <= 9; ++i) {
   
        a[i] = 2021;
    }
    int p = 1;
    while (true) {
   
        if (!solve(p)) break;
        p++;
    }
    cout << p - 1 << endl;
    return 0;
}
3181

C 直线

问题描述
在平面直角坐标系中,两点可以确定一条直线。如果有多点在一条直线上,那么这些点中任意两点确定的直线是同一条。
给定平面上 2 × 3 2 \times 3 2×3 个整点 { ( x , y ) ∣ 0 ≤ x < 2 , 0 ≤ y < 3 , x ∈ Z , y ∈ Z } \{(x, y)|0 ≤ x < 2, 0 ≤ y < 3, x ∈ Z, y ∈ Z\} { (x,y)0x<2,0y<3,xZ,yZ},即横坐标是 0 0 0 1 1 1 (包含 0 0 0 1 1 1) 之间的整数、纵坐标是 0 0 0 2 2 2 (包含 0 0 0 2 2 2) 之间的整数的点。这些点一共确定了 11 11 11 条不同的直线。
给定平面上 20 × 21 20 \times 21 20×21 个整点 { ( x , y ) ∣ 0 ≤ x < 20 , 0 ≤ y < 21 , x ∈ Z , y ∈ Z } \{(x, y)|0 ≤ x < 20, 0 ≤ y < 21, x ∈ Z, y ∈ Z\} { (x,y)0x<20,0y<21,xZ,yZ},即横坐标是 0 0 0 19 19 19 (包含 0 0 0 19 19 19) 之间的整数、纵坐标是 0 0 0 20 20 20 (包含 0 0 0 20 20 20) 之间的整数的点。请问这些点一共确定了多少条不同的直线。

题解
计算几何?
点两两连线,算出 k , b k, b k,b 放进set
(竖直和水平线另算,避免 k k k 0 0 0 ∞ \infty

#include <bits/stdc++.h>
using namespace std;
#define N 502
#define X 21
#define Y 20
struct Point {
   
    int x, y;
    Point() {
   }
    Point(int _x, int _y) : x(_x), y(_y) {
   }
} a[N];
int cnt_point;
struct Line {
   
    double k, b;
    Line() {
   }
    Line(double _k, double _b) : k(_k), b(_b) {
   }
    bool operator<(const Line &y) const {
   
        if (k == y.k) {
   
            return b < y.b;
        }
        return k < y.k;
    }
};
set<Line> e;
void addedge(Point x, Point y) {
   
    if (x.x == y.x || x.y == y.y) return;
    double fm = (y.x - x.x) * 1.0;
    double k = (y.y - x.y) * 1.0 / fm;
    double b = (x.y * y.x - x.x * y.y) * 1.0 / fm;
    e.insert(Line(k, b));
}
int main() {
   
    for (int x = 0; x < X; ++x) {
   
        for (int y = 0; y < Y; ++y) {
   
            a[cnt_point++] = Point(x, y);
        }
    }
    for (int i = 0; i < cnt_point; ++i) {
   
        for (int j = 0; j < cnt_point; ++j) {
   
            addedge(a[i], a[j]);
        }
    }
    cout << e.size() + X + Y << endl;
    return 0;
}
40257

D 货物摆放

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

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

题解
数论
n n n 分解质因数
2021041820210418 = 2 × 3 × 3 × 3 × 17 × 131 × 2857 × 5882353 2021041820210418 = 2 \times 3 \times 3 \times 3 \times 17 \times 131 \times 2857 \times 5882353 2021041820210418=2×3×3×3×17×131×2857×5882353

解法一
dfs 算方案放进 set

#include <bits/stdc++.h>
#define ll long long
using namespace std;
ll n = 2021041820210418;
ll a[102], cnt;
struct Node {
   
    ll l, w, h;
    Node() {
   }
    Node(ll _l, ll _w, ll _h) : l(_l), w(_w), h(_h) {
   }
    bool operator<(const Node &y) const {
   
        if (l == y.l) {
   
            if (w == y.w) {
   
                return h < y.h;
            }
            return w < y.w;
        }
        return l < y.l;
    }
};
set<Node> ans;
void dfs(int p, ll l, ll w, ll h) {
   
    if (p == cnt) {
   
        ans.insert(Node(l, w, h));
        return;
    }
    dfs(p + 1, l * a[p], w, h);
    dfs(p + 1, l, w * a[p], h);
    dfs(p + 1, l, w, h * a[p]);
}
int main() {
   
    for (ll i = 2; i * i <= n; ++i) {
   
        if (n % i == 0) {
   
            a[cnt++] = i;
            n /= i;
            i--;
        }
    }
    a[cnt++] = n;
    dfs(0, 1, 1, 1);
    cout << ans.size() << endl;
    return 0;
}

解法二
排列组合
注意到有 3 3 3 3 3 3
3 5 × ( 1 + 2 + 2 + 2 + 3 ) = 2430 3 ^ 5 \times (1+2+2+2+3)=2430 35×(1+2+2+2+3)2430

2430

E 路径

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

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

题解
图论
根据题意建边,跑最短路Dijkstra 即可

#include <bits/stdc++.h>
#define N 2022
#define M 100005
#define INF 0x3f3f3f3f
using namespace std;
int gcd(int x, int y) {
    return (x % y) ? gcd(y, x % y) : y; }
int lcm(int x, int y) {
    return x / gcd(x, y) * y; }
struct Edge {
   
    int v, w, nxt;
} e[M];
int head[N], cnt;
void addedge(int u, int v, int w) {
   
    e[++cnt].v = v;
    e[cnt].w = w;
    e[cnt].nxt = head[u];
    head[u] = cnt;
}
struct Node {
   
    int u, d;
    Node() {
   }
    Node(int _u, int _d) : u(_u), d(_d) {
   }
    bool operator<(const Node &x) const {
    return d > x.d; }
};
int dis[N];
int dijkstra(int s, int t) {
   
    for (int i = 1; i < N; ++i) {
   
        dis[i] = INF;
    }
    dis[s] = 0;
    priority_queue<Node> q;
    q.push(Node(s, 0));
    while (!q.empty()) {
   
        Node tmp = q.top();
        q.pop();
        int u = tmp.u, d = tmp.d;
        if (d != dis[u]) continue;
        for (int i = head[u]; i; i = e[i].nxt) {
   
            int v = e[i].v, w = e[i].w;
            if (dis[v] > dis[u] + w) {
   
                dis[v] = dis[u] + w;
                q.push(Node(v, dis[v]));
            }
        }
    }
    return dis[t];
}
int main() {
   
    for (int i = 1; i < N; ++i) {
   
        for (int j = 1; j < N; ++j) {
   
            if (abs(i - j) <= 21) {
   
                addedge(i, j, lcm(i, j));
            }
        }
    }
    cout << dijkstra(1, 2021) << endl;
    return 0;
}
10266837

编程题

F 时间显示

问题描述
小蓝要和朋友合作开发一个时间显示的网站。在服务器上,朋友已经获取了当前的时间,用一个整数表示,值为从 1970 1970 1970 1 1 1 1 1 1 00 : 00 : 00 00:00:00 00:00:00 到当前时刻经过的毫秒数。
现在,小蓝要在客户端显示出这个时间。小蓝不用显示出年月日,只需要显示出时分秒即可,毫秒也不用显示,直接舍去即可。
给定一个用整数表示的时间,请将这个时间对应的时分秒输出。

输入格式
输入一行包含一个整数,表示时间。
输出格式
输出时分秒表示的当前时间,格式形如 H H : M M : S S HH:MM:SS HH:MM:SS,其中 H H HH HH 表示时,值为 0 0 0 23 23 23 M M MM MM 表示分,值为 0 0 0 59 59 59 S S SS SS 表示秒,值为 0 0 0 59 59 59。时、分、秒不足两位时补前导 0 0 0

样例输入 1

46800999

样例输出 1

13:00:00

样例输入 2

1618708103123

样例输出 2

01:08:23

评测用例规模与约定
对于所有评测用例,给定的时间为不超过 1 0 18 10^{18} 1018 的正整数。

题解
模拟
注意 1 1 1 = 1000 =1000 =1000 毫秒

#include <bits/stdc++.h>
#define ll long long
using namespace std;
ll n;
ll hh, mm, ss;
int main() {
   
    scanf("%lld", &n);
    n /= 1000;
    ss = n % 60;
    n /= 60;
    mm = n % 60;
    n /= 60;
    hh = n % 24;
    printf("%02lld:%02lld:%02lld\n", hh, mm, ss);
    return 0;
}

G 砝码称重

问题描述
你有一架天平和 N N N 个砝码,这 N N N 个砝码重量依次是 W 1 , W 2 , ⋯   , W N W_1, W_2,\cdots, W_N W1,W2,,WN。请你计算一共可以称出多少种不同的重量?
注意砝码可以放在天平两边。

输入格式
输入的第一行包含一个整数 N N N
第二行包含 N N N 个整数: W 1 , W 2 , W 3 , ⋯   , W N W_1, W_2, W_3,\cdots, W_N W1,W2,W3,,WN
输出格式
输出一个整数代表答案。

样例输入

3
1 4 6

样例输出

10

样例说明
能称出的 10 10 10 种重量是: 1 、 2 、 3 、 4 、 5 、 6 、 7 、 9 、 10 、 11 1、2、3、4、5、6、7、9、10、11 123456791011
1 = 1 1 = 1 1=1
2 = 6 − 4 2 = 6 − 4 2=64 (天平一边放 6 6 6,另一边放 4 4 4);
3 = 4 − 1 3 = 4 − 1 3=41
4 = 4 4 = 4 4=4
5 = 6 − 1 5 = 6 − 1 5=61
6 = 6 6 = 6 6=6
7 = 1 + 6 7 = 1 + 6 7=1+6
9 = 4 + 6 − 1 9 = 4 + 6 − 1 9=4+61
10 = 4 + 6 10 = 4 + 6 10=4+6
11 = 1 + 4 + 6 11 = 1 + 4 + 6 11=1+4+6

评测用例规模与约定
对于 50 % 50\% 50% 的评测用例, 1 ≤ N ≤ 15 1 \leq N \leq 15 1N15
对于所有评测用例, 1 ≤ N ≤ 100 1 \leq N \leq 100 1N100 N N N 个砝码总重不超过 100000 100000 100000

题解
类dp
注意 0 0 0 不算

#include <bits/stdc++.h>
#define N 102
#define MAX_WEIGHT 100005
using namespace std;
int n, w[N], sum_weight, ans;
set<int> st, st2;
bool vis[MAX_WEIGHT];
int main() {
   
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
   
        scanf("%d", &w[i]);
        sum_weight += w[i];
    }
    st.insert(0);
    st2.insert(0);
    for (int i = 0; i < n; ++i) {
   
        for (set<int>::iterator iter = st.begin(); iter != st.end(); ++iter) {
   
            st2.insert((*iter) + w[i]);
            st2.insert((*iter) - w[i]);
        }
        st = st2;
    }
    for (set<int>::iterator iter = st.begin(); iter != st.end(); ++iter) {
   
        vis[abs(*iter)] = true;
    }
    for (int i = 1; i <= sum_weight; ++i) {
   
        if (vis[i]) {
   
            ++ans;
        }
    }
    printf("%d\n", ans);
}

H 杨辉三角形

问题描述
下面的图形是著名的杨辉三角形:

如果我们按从上到下、从左到右的顺序把所有数排成一列,可以得到如下数列:
1 , 1 , 1 , 1 , 2 , 1 , 1 , 3 , 3 , 1 , 1 , 4 , 6 , 4 , 1 , ⋯ 1, 1, 1, 1, 2, 1, 1, 3, 3, 1, 1, 4, 6, 4, 1,\cdots 1,1,1,1,2,1,1,3,3,1,1,4,6,4,1,
给定一个正整数 N N N,请你输出数列中第一次出现 N N N 是在第几个数?

输入格式
输入一个整数 N N N
输出格式
输出一个整数代表答案。

样例输入

6

样例输出

13

评测用例规模与约定
对于 20 % 20\% 20% 的评测用例, 1 ≤ N ≤ 10 1 \leq N \leq 10 1N10
对于所有评测用例, 1 ≤ N ≤ 1000000000 1 \leq N \leq 1000000000 1N1000000000

题解
注意到有 n = C n 1 n = C_n^1 n=Cn1

若不存在 n = C i j n = C_i^j n=Cij n < C m 2 , i < m n < C_m^2, i<m n<Cm2,i<m ,则 n n n 只可能在 C n 1 C_n^1 Cn1 的位置

#include <bits/stdc++.h>
#define ll long long
#define N 100005
using namespace std;
ll n, c[N], p, q;
bool flag;
int main() {
   
    scanf("%lld", &n);
    if (n == 1) {
   
        printf("1\n");
        return 0;
    }
    c[0] = c[1] = 1;
    p = 1;
    while (c[2] < n) {
   
        ++p;
        c[p] = 1;
        for (int i = p - 1; i > 0; --i) {
   
            c[i] += c[i - 1];
        }
        q = lower_bound(c, c + p / 2, n) - c;
        if (c[q] == n) {
   
            flag = true;
            break;
        }
    }
    if (flag) {
   
        printf("%lld\n", (1 + p) * p / 2ll + q + 1ll);
    } else {
   
        printf("%lld\n", (1 + n) * n / 2ll + 2ll);
    }
    return 0;
}

I 双向排序

问题描述
给定序列 ( a 1 , a 2 , ⋯   , a n ) = ( 1 , 2 , ⋯   , n ) (a_1, a_2,\cdots, a_n) = (1, 2,\cdots, n) (a1,a2,,an)=(1,2,,n),即 a i = i a_i = i ai=i
小蓝将对这个序列进行 m m m 次操作,每次可能是将 a 1 , a 2 , ⋯   , a q i a_1, a_2,\cdots, a_{q_i} a1,a2,,aqi 降序排列,或者将 a q i , a q i + 1 , ⋯   , a n a_{q_i}, a_{q_{i+1}},\cdots, a_n aqi,aqi+1,,an 升序排列。
请求出操作完成后的序列。

输入格式
输入的第一行包含两个整数 n , m n, m n,m,分别表示序列的长度和操作次数。接下来 m m m 行描述对序列的操作,其中第 i i i 行包含两个整数 p i p_i pi, q i q_i qi 表示操作类型和参数。当 p i = 0 p_i = 0 pi=0 时,表示将 a 1 , a 2 , ⋯   , a q i a_1, a_2,\cdots, a_{q_i} a1,a2,,aqi 降序排列;当 p i = 1 p_i = 1 pi=1 时,表示将 a q i , a q i + 1 , ⋯   , a n a_{q_i}, a_{q_{i+1}},\cdots, a_n aqi,aqi+1,,an 升序排列。
输出格式
输出一行,包含 n n n 个整数,相邻的整数之间使用一个空格分隔,表示操作完成后的序列。

样例输入

3 3
0 3
1 2
0 2

样例输出

3 1 2

样例说明
原数列为 ( 1 , 2 , 3 ) (1, 2, 3) (1,2,3)
1 1 1 步后为 ( 3 , 2 , 1 ) (3, 2, 1) (3,2,1)
2 2 2 步后为 ( 3 , 1 , 2 ) (3, 1, 2) (3,1,2)
3 3 3 步后为 ( 3 , 1 , 2 ) (3, 1, 2) (3,1,2)。与第 2 2 2 步操作后相同,因为前两个数已经是降序了。

评测用例规模与约定
对于 30 % 30\% 30% 的评测用例, n , m ≤ 1000 n, m \leq 1000 n,m1000
对于 60 % 60\% 60% 的评测用例, n , m ≤ 5000 n, m \leq 5000 n,m5000
对于所有评测用例, 1 ≤ n , m ≤ 100000 , 0 ≤ p i ≤ 1 , 1 ≤ q i ≤ n 1 \leq n, m \leq 100000,0 \leq p_i \leq 1,1 \leq q_i \leq n 1n,m1000000pi11qin

题解
暴力 sort ,时间复杂度 O ( m n log ⁡ n ) O(mn \log n) O(mnlogn) ,骗 60 % 60\% 60%

#include <bits/stdc++.h>
#define N 100005
using namespace std;
int n, m;
int a[N], p[N], q[N];
int main() {
   
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) {
   
        a[i] = i;
    }
    for (int i = 1; i <= m; ++i) {
   
        scanf("%d%d", &p[i], &q[i]);
        if (p[i]) {
   
            sort(a + q[i], a + n + 1);
        } else {
   
            sort(a + 1, a + q[i] + 1, greater<int>());
        }
    }
    for (int i = 1; i <= n; ++i) {
   
        printf(" %d" + !(i - 1), a[i]);
    }
    printf("\n");
    return 0;
}

J 括号序列

问题描述
给定一个括号序列,要求尽可能少地添加若干括号使得括号序列变得合法,当添加完成后,会产生不同的添加结果,请问有多少种本质不同的添加结果。两个结果是本质不同的是指存在某个位置一个结果是左括号,而另一个是右括号。
例如,对于括号序列 ( ( ( ) ((() (((),只需要添加两个括号就能让其合法,有以下几种不同的添加结果: ( ) ( ) ( ) ()()() ()()() ( ) ( ( ) ) ()(()) ()(()) ( ( ) ) ( ) (())() (())() ( ( ) ( ) ) (()()) (()()) ( ( ( ) ) ) ((())) ((()))

输入格式
输入一行包含一个字符串 s s s,表示给定的括号序列,序列中只有左括号和右括号。
输出格式
输出一个整数表示答案,答案可能很大,请输出答案除以 1000000007 1000000007 1000000007 (即 1 0 9 + 7 10^9 + 7 109+7) 的余数。

样例输入

((()

样例输出

5

评测用例规模与约定
对于 40 % 40\% 40% 的评测用例, ∣ s ∣ ≤ 200 \lvert s \rvert \leq 200 s200
对于所有评测用例, 1 ≤ ∣ s ∣ ≤ 5000 1 \leq \lvert s \rvert \leq 5000 1s5000

题解
特判合法括号序列输出 0 0 0
特判样例骗分
正解暂无

#include <bits/stdc++.h>
using namespace std;
string s;
int cnt;
bool flag = true;
int main() {
   
    cin >> s;
    for (int i = 0; i < s.length(); ++i) {
   
        if (s[i] == '(') {
   
            ++cnt;
        } else {
   
            if (cnt <= 0) {
   
                flag = false;
                break;
            }
            --cnt;
        }
    }
    if (cnt) {
   
        flag = false;
    }
    if (flag) {
   
        printf("0\n");
    } else {
   
        if (s == "((()") {
   
            printf("5\n");
        } else {
   
            printf("%d\n", s.length());
        }
    }
    return 0;
}

转载:https://blog.csdn.net/qq_45799024/article/details/115838048
查看评论
* 以上用户言论只代表其个人观点,不代表本网站的观点或立场