本题解为非官方题解,可能存在包括但不限于下列问题
- 答案错误
- 时间复杂度太高,无法在规定时间内得出结果
填空题答案速览
- 67108864
- 3181
- 40257
- 2430
- 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)∣0≤x<2,0≤y<3,x∈Z,y∈Z},即横坐标是 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)∣0≤x<20,0≤y<21,x∈Z,y∈Z},即横坐标是 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 L、W、H 的货物,满足 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×4、1×2×2、1×4×1、2×1×2、2×2×1、4×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 1、2、3、4、5、6、7、9、10、11。
1 = 1 1 = 1 1=1;
2 = 6 − 4 2 = 6 − 4 2=6−4 (天平一边放 6 6 6,另一边放 4 4 4);
3 = 4 − 1 3 = 4 − 1 3=4−1;
4 = 4 4 = 4 4=4;
5 = 6 − 1 5 = 6 − 1 5=6−1;
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+6−1;
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 1≤N≤15。
对于所有评测用例, 1 ≤ N ≤ 100 1 \leq N \leq 100 1≤N≤100, 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 1≤N≤10;
对于所有评测用例, 1 ≤ N ≤ 1000000000 1 \leq N \leq 1000000000 1≤N≤1000000000。
题解
注意到有 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,m≤1000;
对于 60 % 60\% 60% 的评测用例, n , m ≤ 5000 n, m \leq 5000 n,m≤5000;
对于所有评测用例, 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 1≤n,m≤100000,0≤pi≤1,1≤qi≤n。
题解
暴力 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 ∣s∣≤200。
对于所有评测用例, 1 ≤ ∣ s ∣ ≤ 5000 1 \leq \lvert s \rvert \leq 5000 1≤∣s∣≤5000。
题解
特判合法括号序列输出 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