【初赛】CSP 2020 第一轮（初赛）模拟记录
感觉初赛不过关，洛谷上找了一套没做过的来练习。
顺便写了详细的题解。
试题用时：1h
单项选择：
第 1 题
十进制数 114 的相反数的 8 位二进制补码是：
A.10001110
B.10001101
C.01110010
D.01110011
题目好臭
\(114\) 二进制为 \(1110010\)，其补码取反，符号位变 \(1\)，最后 \(+1\) 即可。
答案：\(\color{green} A\)
第 2 题
以下哪个网站不是 Online Judge（在线程序判题系统）？
Online Judge 可以查看算法题目，提交自己编写的程序，然后可以获得评测机反馈的结果。
A.Luogu
B.Gitee
C.LeetCode
D.Codeforces
\(A,C,D\) 耳熟能详。
答案：\(\color{green} B\)
第 3 题
小 A 用字母 A 表示 1，B 表示 2，以此类推，用 26 表示 Z。
对于 27 以上的数字，可以用两位或者更长的字符串来对应.
例如 AA 对应 27，AB 对应 28，AZ 对应 52，AAA 对应 703……
那么 BYT 字符串对应的数字是什么？
A.2018
B.2020
C.2022
D.2024
byt?
\(ans=2\times 26^2+25 \times 26 +20=2022\)
答案：\(\color{green} C\)
第 4 题
UIM 拍摄了一张照片，其分辨率是 4096\times 2160，每一个像素都是 24 位真彩色。
在没有压缩的情况下，这张图片占用空间接近以下哪个值？
A.8MB
B.25MB
C.200MB
D.200KB
\(\frac{4096\times 2160 \times 24 bite}{1024\times 1024 \times 8} \approx 25 MB\)
答案：\(\color{green} B\)
第 5 题
在一个长度为 n 的数组中找到第 k 大的数字，平均的算法时间复杂度最低的是：
A.O(n)
B.O(nk)
C.O(nlogn)
D.O(n^2)
\(D\)：使用 \(O(n^2)\) 的排序，比如冒泡排序，然后输出 \(a[k]\) 即可
\(C\)：使用 \(O(nlogn)\) 的排序，比如 \(sort()\)，然后同上
\(B\)：两层循环，依次找出 \(1st,2nd,2rd,4th...(k-1)th,kth\) 大的数即可
\(A\)：利用快排的思想，每次在目标的区间内选一个数 \(i\)，然后把比 \(a[i]\) 小的都放在其左，比\(a[i]\)大的都放在其右。判断 \(a[i]\) 在这一次后的位置与k的大小关系，然后选择 \(k\) 所在的那个区间重复进行。时间复杂度：\(n+n/2+n/4+n/8+.......=2n=O(n)\)
答案：\(\color{green} A\)
错解：\(\color{red} C\)
第 6 题
对于“树”这种数据结构，正确的有：
1、一个有 n 个顶点、n−1 条边的图是树
2、一个树中的两个顶点之间有且只有一条简单路径
3、树中一定存在度数不大于 1 的顶点
4、树可能存在环
A.1、2、4
B.1、2、3
C.2、3
D.1、2
\(1\)：要是联通图
\(2\)：对
\(3\)：叶子结点
\(4\)：不可能
答案：\(\color{green} C\)
第 7 题
博艾中学进行了一次信息学会考测试，其优、良、及格、不及格的试卷数量分别为 10,13,14,5 张。
现在这些卷子混在一起，要将这些卷子按照等级分为 4 叠。
分卷子的方法是，每次将一叠有不同等级答卷的卷子分为两堆，使得这两堆中没有相同等级的卷子，然后可以再分，直到分为 444 叠。
要分完这些卷子，至少需要多少次“分卷子”的操作？
将一堆数量为 n 的卷子分成两堆，就会产生 n 次分卷子的操作。
A.84
B.93
C.78
D.85
类似于合并果子的最小代价。
最优方案是：\(42 = 15 + 27 = (10 + 3) + (13 + 14)\)，代价为 \(42 + 15 + 27 = 84\)
蒙对了
答案：\(\color{green} A\)
第 8 题
一个二叉树的前序遍历是 HGBDAFEC，中序遍历是 BGHFAED，同时采用顺序存储结构，
即用一维数组元素存储该二叉树中的结点，则该数组的最大下标至少为（ ）
A.7
B.13
C.15
D.12
根据题意画出以下二叉树，并标上下标即可。
答案：\(\color{green} B\)
第 9 题
在 C++ 语言中，如果 a=1;b=0;c=1; 那么以下表达式中为 1 的是：
A.a&&b||b&&c
B.a+b>c||b
C.!(!c&&(!a||b))
D.a+b+c
手算即可。
答案：\(\color{green} C\)
第 10 题
在一个初始长度为 n 的链表中连续进行 k 次操作，每次操作是读入两个数字 ai 和 bi，
在链表中找到元素为 ai 的结点（假设一定可以找到），然后将 b i这个元素插入到这个结点前面。
在最理想的情况下，链表访问的结点数量最少可能是多少（不算将要插入的结点）？
A.n 次
B.k 次
C.nk 次
D.n+k 次
每次都刚好是第一个就找到了，一共 \(k\) 次。
答案：\(\color{green} B\)
第 11 题
A 班有 5 名风纪委员，B 班有 4 名风纪委员，C 班有 3 名风纪委员。
现在需要这些同学中选取 6 名风纪委员巡逻，如果只关注各班派出的风纪委员人数，有几种不同的方案？
A.9
B.12
C.15
D.18
以下几种情况（依次为 \(A、B、C\)）:
\(5,1,0/5,0,1/4,1,1/4,2,0/4,0,2/3,1,2/\)
\(3,2,1/3,3,0/3,0,3/2,4,0/2,3,1/2,1,3/\)
\(2,2,2/1,4,1/1,3,2/1,2,3/0,4,2/0,3,3\)
答案：\(\color{green} D\)
第 12 题
以下哪种排序算法的时间复杂度是 O(n^2)？
A.计数排序
B.插入排序
C.希尔排序
D.归并排序
送分。
答案：\(\color{green} B\)
第 13 题
已知 rand() 可以生成一个 0 到 32767 的随机整数，如果希望得到一个范围在 [a,b) 的随机整数
，a 和 b 均是不超过 100 的正整数且 a<b，那么可行的表达式是什么？
A.(rand()%(b-a))+a
B.(rand()%(b-a+1))+a
C.(rand()%(b-a))+a+1
D.(rand()%(b-a+1))+a+1
\(rand()\mod(b-a)\) 可产生 \(0\) 到 \(b-a-1\) 的随机数，再 \(+a\) 即可。
答案：\(\color{green} A\)
第 14 题
一个 7 个顶点的完全图需要至少删掉多少条边才能变为森林？
A.16
B.21
C.15
D.6
首先，有七个点的完全图一共有 \(1+2+3+4+5+6=21\) 条边。
但注意：森林可以只有一棵树！！
所以 \(7\) 个节点的树有 \(6\) 条边，应删除 \(21-6=15\) 条边
答案：\(\color{green} C\)
错解：\(\color{red} A\)
第 15 题
2020 年 8 月，第（ ）届全国青少年信息学奥林匹克竞赛在（ ）举行？
A.26，广州
B.26，长沙
C.37，广州
D.37，长沙
人品题。
答案：\(\color{green} D\)
错解：\(\color{red} C\)
阅读程序：
第 16 题
#include<iostream>
using namespace std;
#define MAXN 20
int gu[MAXN][MAXN];
int luo(int n, int m) {
if(n <= 1 || m < 2)
return 1;
if(gu[n][m] != -1)
return gu[n][m];
int ans = 0;
for(int i = 0; i < m; i += 2)
ans += luo(n - 1, i);
gu[n][m] = ans;
return ans;
}
int main() {
int n, m;
cin >> n >> m;
for(int i = 0; i < MAXN; i++)
for(int j = 0; j < MAXN; j++)
gu[i][j] = -1;
cout << luo(n, m);
return 0;
}
判断题
1、（1 分）luo 函数中，\(m\) 的值不可能是奇数。（ ）
输入一个奇数就好了。
答案：\(\color{green} F\)
2、（1 分）若将第 \(11\) 行的 \(<\) 改为 \(<=\)，程序的输出结果可能会改变。（ ）
显然，循环会多执行。
答案：\(\color{green} T\)
3、若将第 \(8,9,13\) 行删除，程序的运行的结果不变（ ）
只是去掉了记忆化搜索的优化，答案是不会变的。只是可能 TLE
答案：\(\color{green} T\)
4、在添加合适的头文件后，将第 \(19\) 到 \(21\) 行替换为 memset(gu,255,sizeof(gu)); 可以起到相同的作用（ ）
涨芝士了。
答案：\(\color{green} T\)
错解：\(\color{red} F\)
选择题
1、（4 分）若输入数据为 4 8，则输出为（ ）。
A.7 B.8 C.15 D.16
手算即可。
答案：\(\color{green} B\)
2、最坏情况下，此程序的时间复杂度是（ ）。
A.O(m^2 n)
B.O(nm!)
C.O(n^2)
D.O(n^2 m)
记忆化计算 \(nm\) 个值，每次计算复杂度为 \(O(m)\)，所以为\(O(m^2n)\)
答案：\(\color{green} A\)
错解：\(\color{red} B\)
第 17 题
#include<bits/stdc++.h>
using namespace std;
int n, m;
int f[101][101];
int F[101][101];
int main() {
scanf("%d%d", &n, &m); // n的值在1到100之间
memset(f, -1, sizeof(f));
for(int i = 1; i <= m; i++) {
int u, v, w; // w的值在0到10000之间
scanf("%d%d%d", &u, &v, &w);
f[u][v] = f[v][u] = w;
}
for(int k = 1; k <= n; k++)
for(int i = 1; i <= n; i++)
for(int j = 1; j <= n; j++)
if(f[i][k] != -1 && f[k][j] != -1)
if(f[i][j] == -1||f[i][j]>f[k][j]+f[i][k])
f[i][j] = f[i][k] + f[k][j];
int ans = 2147483647;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= n; j++) {
for(int x = 1; x <= n; x++)
for(int y = 1; y <= n; y++)
F[x][y] = f[x][y];
F[i][j] = F[j][i] = 0;
for(int x = 1; x <= n; x++)
for(int y = 1; y <= n; y++)
if(F[x][y]==-1||F[x][y]>F[x][i]+F[i][y])
F[x][y] = F[x][i] + F[i][y];
for(int x = 1; x <= n; x++)
for(int y = 1; y <= n; y++)
if(F[x][y]==-1||F[x][y]>F[x][j]+F[j][y])
F[x][y] = F[x][j] + F[j][y];
int res = 0;
for(int x = 1; x <= n; x++)
for(int y = 1; y < x; y++)
res += F[x][y];
ans = min(res, ans);
}
printf("%d\n", ans);
return 0;
}
看到 \(k,i,j\) 循环直接 \(Floyd\)。
判断题
1、（1 分）\(14\) 到 \(16\) 行，将外层到内层的循环变量依次调整为 \(i,j,k\)，程序的运行的结果不变。（ ）
\(Floyd\) 算法，显然不行。
答案：\(\color{green} F\)
2、这个程序的时间复杂度和 \(m\) 无关。（ ）
要枚举边，于 \(m\) 有关，但影响很小。
答案：\(\color{green} F\)
3、\(20\) 行的 \(ans\) 如果初始化为 \(10^7\) 时，可能无法得到正确结果。（ ）
一条路 \(n \times w =10^6\)，再 \(\times n\) 到 \(10^8\)，不够。我当时少乘了 n
答案：\(\color{green} F\)
错解：\(\color{red} T\)
4、若将第 27 到 30 行的部分和 31 到 34 行的两个部分互换，程序的运行的结果不变。（ ）
都是松弛操作，前后顺序无所谓。
答案：\(\color{green} T\)
选择题
1、若输入数据为 4 5/1 2 3/1 3 6/2 3 4/2 4 7/3 4 2（其中“/”为换行符），则输出为（ ）。
A.14 B.18 C.21 D.28
好像得手算
答案：\(\color{green} A\)
错解：\(\color{red} B\)
2、这个程序使用了（ ）算法。
A.Floyd B.Dijkstra C.Prim D.Kruskal
显然。
答案：\(\color{green} A\)
第 18 题
#include<bits/stdc++.h>
using namespace std;
#define MOD 19260817
#define MAXN 1005
long long A[MAXN][MAXN] = {0}, sum[MAXN][MAXN] = {0};
int n, m, q;
int main() {
A[1][1] = A[1][0] = 1;
for(int i = 2; i <= 1000; i++) {
A[i][0] = 1;
for(int j = 1; j <= i; j++)
A[i][j] = (A[i - 1][j] + A[i - 1][j - 1]) % MOD;
}
for(int i = 1; i <= 1000; i++)
for(int j = 1; j <= 1000; j++)
sum[i][j] = (sum[i - 1][j] + sum[i][j - 1]
- sum[i - 1][j - 1] + A[i][j] + MOD) % MOD;
int q;
cin >> q;
while(q--) {
int n, m;
cin >> n >> m;
cout << sum[n][m] << endl;
}
return 0;
}
一眼杨辉三角。
判断题
1、（1 分）当 \(i\leq j\) 时，\(A[i][j]\) 的值是 \(0\)。（ ）
\(i=j\) 时值为 \(1\) 。这个s*脑抽了
答案：\(\color{green} F\)
错解：\(\color{red} T\)
2、当 \(i>j\) 时，\(A[i][j]\) 的值相当于从 \(i\) 个不同元素中取出 \(j\) 个元素的排列数。（ ）
是组合数而不是排列数。
答案：\(\color{green} F\)
3、\(sum[i][j]\) 的值（\(1<j<i\leq 1000\)）不小于 \(sum[i-1][j-1]\) 的值。（ ）
有取模运算，所以不一定。
答案：\(\color{green} F\)
4、若将第 \(12\) 行改为 \(A[i][j]=(A[i-1][j]+A[i-1][j-1]+MOD)%MOD;\)，程序的运行的结果不变。（ ）
加上 \(MOD\) 再取模显然不变。
答案：\(\color{green} T\)
选择题
1、（4 分）\(A[i][j]（1\leq i\leq 10, 1\leq j\leq 10）\)的所有元素中，最大值是（ ）。
A.126 B.276 C.252 D.210
手算即可，即杨辉三角前 \(11\) 行最大的数。
答案：\(\color{green} C\)
2、若输入数据为 1/5 3（其中“/”为换行符），则输出为（ ）。
A.10 B.35 C.50 D.24
用画好的杨辉三角算一下前缀和即可（注意第一列不用加）。
答案：\(\color{green} C\)
完善程序：
第 19 题
（封禁 xxs）现有 \(n\) 个 xxs（编号为 \(1\) 到 \(n\)），每个 xxs 都有一个关注者，第 \(i\) 个 xxs 的关注者是 \(a_i\)。现在管理员要将其中的一些 xxs 的账号封禁，但需要注意的是如果封禁了第 \(i\) 个人，那么为了不打草惊蛇，就不能封禁他的关注者 \(a_i\)。现在想知道最多可以封禁多少个 xxs。
输入第一行是一个不超过 \(300000\) 的整数 \(n\)，第二行是 \(n\) 个 \(1\) 到 \(n\) 的整数表示 \(a_i\)。
输出一行，一个整数表示答案。
#include <cstdio>
using namespace std;
#define MAXN 300005
int n, ans = 0, a[MAXN], in[MAXN] = {0};
bool vis[MAXN] = {0};
void dfs(int cur, int w) {
if(vis[cur])
return;
vis[cur] = true;
if(w == 1) ans++;
①_______
if(②_______)
dfs(a[cur], ③_______);
}
int main() {
scanf("%d", &n);
for(int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
in[a[i]]++;
}
for(int i = 1; i <= n; i++)
if(!in[i]) ④_______;
for(int i = 1; i <= n; i++)
if(⑤_______) dfs(i, 0);
printf("%d\n", ans);
return 0;
}
1.
A.a[cur]=cur;
B.in[a[cur]]=0;
C.in[a[cur]]--;
D.in[cur]--;
2.
A.in[a[cur]]!=0||w==1
B.in[a[cur]]==0||w==0
C.in[a[cur]]!=0||w==0
D.in[a[cur]]==0||w==1
3.
A.0
B.1
C.w
D.1-w
4.
A.dfs(i,1)
B.dfs(i,0)
C.dfs(a[i],1)
D.dfs(a[i],0)
5.
A.!in[i]
B.in[i]
C.!vis[i]
D.vis[i]
\(vis\) 数组表示有没有遍历到，\(in\) 数组表示一个点的入度，\(w\) 记录有没有被删除。
1：这个点遍历了，相当于去掉它
2：如果这个点没有入度了，相当于没有限制了，可以直接跑。如果 \(w=0\)，说明它的父亲是没有删除的，那么自然它也可以遍历
3：父亲删除了，自己不能删；父亲没删，自己可以删
4：每个没有父亲的点开始遍历
5：把没有遍历到的点遍历完
答案：\(\color{green} {CDDAC}\)
错解：\(\color{green} C\)\(\color{red} B\)\(\color{green} {DAC}\)
第 20 题：
（烧作业）某课作业布置了 \(N(3\leq N\leq 100000)\) 个题目，第 \(i\) 题对应的得分是 \(a_i\)。作业的总得分的计算方式为去掉作业中得分最小的一个题，剩下其它所有题目得分的平均值。但很不幸小 A 遇到了一场火灾，前 \(K(1\leq K\leq N-2)\) 个题目被烧了，无法记录得分。小 A 想知道，\(K\) 是多少时，可以得到最高的作业得分？ 作业被烧了前 \(K\) 页，这时的得分是从第 \(K+1\) 页到最后一页中，去除最小得分后取平均值。
输入第一行是整数 \(N\)，第二行是 \(n\) 个不超过 \(10000\) 的非负整数表示 \(a_i\)。
输出一行，若干个整数表示答案。如果有多个 \(K\)，请依次升序输出。
#include <cstdio>
#include <cmath>
#define min(a,b) (a<b?a:b)
#define MAXN 100002
using namespace std;
int n, k[MAXN], cnt = 0;
int s[MAXN], minScore, sum;
double maxAverage = 0, nowAverage;
int main() {
scanf("%d", &n);
for(int i = 1; i <= n; i++)
scanf("%d", &s[i]);
minScore = s[n];
①________;
for(int i = n - 1; i >= 2; i--) {
minScore = min(minScore, s[i]);
②_________;
nowAverage = ③_________;
if(nowAverage > maxAverage) {
④__________
maxAverage = nowAverage;
} else if(fabs(nowAverage - maxAverage) < 1e-6)
⑤_________;
}
for(int i = cnt; i >= 1; i--)
printf("%d\n", k[i]);
return 0;
}
1.
A.sum=n
B.sum=s[1]
C.sum=s[n]
D.sum=0
2.
A.sum=maxAverage*(n-i)
B.sum+=s[i]
C.sum+=s[n-i]
D.sum=s[i]+minScore
3.
A.(double)(sum+minScore)/(n-i)
B.sum*1.0/(n-i)
C.(int)(sum-minScore)/(n-i)
D.(double)(sum-minScore)/(n-i)
4.
A.k[++cnt]=i;
B.k[cnt++]=i-1
C.cnt=1;k[cnt]=i-1;
D.cnt=0;k[cnt]=i;
5.
A.k[cnt++]=i;
B.k[++cnt]=i-1;
C.k[cnt++]=n-i;
D.k[cnt]=i;
这才是第一题吧
1：从后往前，初值赋 \(s[n]\)。
2：总和加上当前的 \(s[i]\)。
3：算当前平均分，总和减最低分再除以数量。分数转一下 \(double\) 即可。
4：出现更优解就更新最优解和目前答案。
5：出现一样优的解就加上。
答案：\(\color{green} {CBDCB}\)
我才不会告诉你才考了 81
