CSP 2020 入门组第一轮
CSP 2020 入门组第一轮
一、单项选择题
（共15题，每题2分，共计30分）
-
在内存储器中每个存储单元都被赋予一个唯一的序号，称为（）。
A. 地址
B. 序号
C. 下标
D. 编号
解析：内存储器中的每个存储单元我们称之为：地址 -
编译器的主要功能是（ ）。
A. 将源程序翻译成机器指令代码
B. 将源程序重新组合
C. 将低级语言翻译成高级语言
D. 将一种高级语言翻译成另一种高级语言
解析：编译器的主要功能是将源程序翻译成机器指令代码，再让计算机运行该指令代码。 -
设 x=true, y=true, z=false，以下逻辑运算表达式值为真的是（ ）。
A. (y∨z)∧x∧z
B. x∧(z∨y) ∧z
C. (x∧y) ∧z
D. (x∧y)∨(z∨x)
解析：选择D
&&（逻辑与），∧（交集）：同真为真
||（逻辑或），∨（并集）：同假为假 -
现有一张分辨率为 2048×1024 像素的 32 位真彩色图像。请问要存储这张图像，需要多大的存储空间？（ ）。
A. 16MB
B. 4MB
C. 8MB
D. 2MB
解析：
1TB = 2^10 GB = 1024 GB
1GB = 2^10 MB = 1024 MB
1MB = 2^10 KB = 1024 KB
1KB = 2^10 B = 1024 B
1B(Byte,字节) = 8bit（比特）
2048×1024x32/8 Byte
= 2048x1024x32 bit
= 2048x1024x32/8 B
= 2048x1024x32/8/1024 KB
= 2048×1024x32/8/1024/1024 MB
= 8MB -
冒泡排序算法的伪代码如下：
输入：数组L, n ≥ k。输出：按非递减顺序排序的 L。
算法 BubbleSort：
1. FLAG ← n //标记被交换的最后元素位置
2. while FLAG > 1 do
3・ k ← FLAG -1
4・ FLAG ← 1
5・ for j=1 to k do
6. if L(j) > L(j+1) then do
7・ L(j) ↔ L(j+1)
8・ FLAG ← j
对 n 个数用以上冒泡排序算法进行排序，最少需要比较多少次?（ ）。
A. n^2
B. n-2
C. n-1
D. n
解析：个人觉得本题目的描述不严谨，需要比较多少次 ，应当修改为 第6行需要比较多少次，否则会将 第2行的也包含在内，以下讨论皆基于 第6行需要比较多少次。
最好的是直接通过样例得出结果，比如举例：2 1 3，最少比较次数为 2。
仔细分析，最少的比较次数就是当原数列本就是非递减顺序排序的情况，那么 if L(j) > L(j+1) 的执行次数就是跑完一次 for后，FLAG=1就停止，此时执行比较次数为 k，即 n- 次
- 设A是n个实数的数组，考虑下面的递归算法：
XYZ (A[1..n])
1. if n= 1 then return A[1]
2. else temp ← XYZ (A[l..n-1])
3. if temp < A[n]
4. then return temp
5. else return A[n]
请问算法XYZ的输出是什么？（）。
A. A数组的平均
B. A数组的最小值
C. A数组的中值
D. A数组的最大值
解析：仔细读程序，发现每次返回的都是最小值
-
链表不具有的特点是（）。
A. 可随机访问任一元素
B. 不必事先估计存储空间
C. 插入删除不需要移动元素
D. 所需空间与线性表长度成正比
解析：
链表特点：
插入删除元素都不需要移动元素，直接修改元素的pre指针指向的方向即可。
不需要事先估计存储空间，新增元素可以重新开存储空间，再将链表最后的指针指向该空间的地址即可。
链表访问其中元素的时候是从头到尾进行遍历，直到找到该元素，不能像数组那样通过下标直接访问。 -
有 10 个顶点的无向图至少应该有（ ）条边才能确保是一个连通图。
A. 9
B. 10
C. 11
D. 12
解析：图，类似地图，地图上有城市，路线，就对应这图中的节点与边。
无向图：是指路线没有方向，正走反走都可以
连通图：是指一条路可以走完所有点，也可以理解为一笔画完全部图（可以重复）
2个点，如果连通，至少1条边
3个点，如果连通，至少2条边
4个点，如果连通，至少3条边
n个点，如果连通，至少n-1条边 -
二进制数 1011 转换成十进制数是（ ）。
A. 11
B. 10
C. 13
D. 12
解析：1011B=8+2+1=11D -
5 个小朋友并排站成一列，其中有两个小朋友是双胞胎，如果要求这两个双胞胎必须相邻，则有（ ）种不同排列方法?
A. 48
B. 36
C. 24
D. 72
解析：
-
下图中所使用的数据结构是（ )。
A. 栈
B. 队列
C. 二叉树
D. 哈希表
解析：数据结构是指逻辑存储结构
栈：后进先出的线性表
队列：先进先出的线性表
二叉树：一个节点最多两个分支的树
哈希表：<key,value> 形式的映射，如 map<string,int> -
独根树的高度为 1。具有 61 个结点的完全二叉树的高度为（ ）。
A. 7
B. 8
C. 5
D. 6
解析：
发现如果这是满二叉树（除开叶子节点外，其余节点都是满的,都有两个子节点）第i行及前i行节点数量和为: 2^k-1
所以2^6-1 = 63 >= 61,高度为：6 -
干支纪年法是中国传统的纪年方法，由10个天干和12个地支组合成60个天干地支。由公历年份可以根据以下公式和表格换算出对应的天干地支。
天干 =（公历年份）除以10所得余数
地支 =（公历年份）除以12所得余数
例如，今年是 2020 年，2020 除以 10 余数为 0，查表为"庚”；2020 除以 12，余数为 4，查表为“子” 所以今年是庚子年。请问 1949 年的天干地支是（ ）
A. 己酉
B. 己亥
C. 己丑
D. 己卯
解析：1949%10=9， 1949%12=5
第 14 题
10 个三好学生名额分配到 7 个班级，每个班级至少有一个名额，一共有（ ）种不同的分配方案。
A. 84 B. 72 C. 56 D. 504
解析：10个名额分到7个班，要求每个班至少一名，那么也就是相当于每个班都分一个名额后，还剩余3个名额，再分给7个班，有几种情况。
第一类：将3个名额分配给3个班：C(7,3)=7x5=35
第二类：将3个名额分配给2个班=将1个名额分配给1个班+2个名额分配给1个班：C(7,1)C(6,1)=7x6=42
第三类：将3个名额分配给1个班：C(7,1)=7
共有分配方案：35+42+7 = 84，也可以使用插板法。
- 插板法（适用于相同小球放入不同盒子，不允许空盒的情况）
问题：将n个相同小球，放入m个不同盒子，不允许空盒，那么有多少方案？
例如：将10个相同小球，放入7个不同盒子，不允许空盒，那么有多少方案？
只需要插入m-1 块板子就可以将小球分为m个整体，可以插入板子的位置有 n-1 个，所以方案数为 \(C_{n-1}^{m-1}\).
- 有五副不同颜色的手套（共 10 只手套，每副手套左右手各 1 只），一次性从中取 6 只手套，请问恰好能配成两副手套的不同取法有（ ）种。
A. 120
B. 180
C. 150
D. 30
解析：
二、阅读程序
(除特殊说明外，判断题 1.5 分，选择题 3 分，共计 40 分)
程序输入不超过数组或字符串定义的范围；
判断题正确填 √，错误填 ×。
第 16 题(本题共 12 分)
1. #include <cstdlib>
2. #include <iostream>
3. using namespace std;
4.
5. char encoder[26] = {'C','S','P',0};
6. char decoder[26];
7.
8. string st;
9.
10. int main() {
11. int k = 0;
12. for (int i = 0; i < 26; ++i)
13. if (encoder[i] != 0) ++k;
14. for (char x ='A'; x <= 'Z'; ++x) {
15. bool flag = true;
16. for (int i = 0; i < 26; ++i)
17. if (encoder[i] ==x) {
18. flag = false;
19. break;
20. }
21. if (flag) {
22. encoder[k]= x;
23. ++k;
24. }
25. }
26. for (int i = 0; i < 26; ++i)
27. decoder[encoder[i]- 'A'] = i + 'A';
28. cin >> st;
29. for (int i = 0; i < st.length( ); ++i)
30. st[i] = decoder[st[i] -'A'];
31. cout << st;
32. return 0;
33. }
判断题
1） 输入的字符串应当只由大写字母组成，否则在访问数组时可能越界。（ √ ）
2） 若输入的字符串不是空串，则输入的字符串与输出的字符串一定不一样。（ × ）
3） 将第 12 行的“i < 26”改为“i < 16”，程序运行结果不会改变。（ √ ）
4） 将第 26 行的"i < 26”改为“i < 16”，程序运行结果不会改变。（ × ）
单选题
5） 若输出的字符串为"ABCABCABCA"，则下列说法正确的是（ A ）。
A. 输入的字符串中既有S又有P
B. 输入的字符串中既有S又有B
C. 输入的字符串中既有A又有P
D. 输入的字符串中既有A又有B
6）若输出的字符串为"CSPCSPCSPCSP"，则下列说法正确的是（ D ）。
A. 输入的字符串中既有P又有K
B. 输入的字符串中既有J又有R
C. 输入的字符串中既有J又有K
D. 输入的字符串中既有P又有R
解析：这样的题目你想要直接读懂程序太难了，所以直接按照程序模拟一遍，带入部分简单数据尝试运行一下，能理解程序的主要原理即可。但是这样的题目，建议多做笔记，多写草稿，将过程记录着，以防有用。如下程序中就是我所做笔记。
然后就可以直接得出答案，这类题目其实不难，即使看不懂程序，也能做，但是一定要动手演算。
#include <cstdlib>//P16
#include <iostream>
using namespace std;
char encoder[26] = {'C','S','P',0};
char decoder[26];
string st;
int main() {
int k = 0;
for (int i = 0; i < 26; ++i)
if (encoder[i] != 0) ++k;// 字符个数计数 k=3
for (char x ='A'; x <= 'Z'; ++x) {
bool flag = true;
for (int i = 0; i < 26; ++i)
if (encoder[i] ==x) {
flag = false;
break;
}
if (flag) {//如果 x未出现，则存入
//encoder=CSPAB DEFGH IJKLM NOQRT UVWXYZ
encoder[k]= x;
++k;
}
}
for (int i = 0; i < 26; ++i)
decoder[encoder[i]- 'A'] = i + 'A';
//decoder[C-A]=A
//decoder[S-A]=B
//decoder[P-A]=C
//decoder[A-A]=D
//decoder[B-A]=E
//decoder[D-A]=F
//decoder[E-A]=G
//decoder[F-A]=H
//decoder[G-A]=I
//decoder[H-A]=J
//decoder[I-A]=K
//decoder[J-A]=L
//decoder[K-A]=M
//decoder[L-A]=N
//decoder[M-A]=O
//decoder[N-A]=P
//decoder[O-A]=Q
//decoder[Q-A]=R
//decoder[R-A]=S
//decoder[T-A]=T
//decoder[U-A]=U
//decoder[V-A]=V
//decoder[W-A]=W
//decoder[X-A]=X
//decoder[Y-A]=Y
//decoder[Z-A]=Z
cin >> st;//假设：CSP
for (int i = 0; i < st.length( ); ++i)
st[i] = decoder[st[i] -'A'];
//st=ABC
//str=ABCABCABCA
//str=CSPCSPCSPCSP
cout << st;
return 0;
}
第 17 题(本题共 13.5 分)
1. #include <iostream>
2. using namespace std;
3.
4. long long n, ans;
5. int k, len;
6. long long d[1000000];
7.
8. int main() {
9. cin >> n >> k;
10. d[0] = 0;
11. len= 1;
12. ans = 0;
13. for (long long i = 0; i <n; ++i) {
14. ++d[0];
15. for (int j = 0; j + 1<len; ++j) {
16. if (d[j] == k) {
17. d[j] = 0;
18. d[j + 1] += 1;
19. ++ans;
20. }
21. }
22. if (d[len- 1] == k) {
23. d[len - 1] = 0;
24. d[len] =1;
25. ++len;
26. ++ans;
27. }
28. }
29. cout << ans << endl;
30. return 0;
31. }
假设输入的 n 是不超过 \(2^{62}\) 的正整数，k都是不超过 10000 的正整数，完成下面的判断题和单选题：
分析：程序是将n转换为k进制数，len记录转换后的位数，ans记录进位次数；
判断题
1)若 k=l，则输出 ans 时，len=n。（ × ）
2)若 k>l，则输出 ans 时，len —定小于 n。（ × ）
3)若 k>l，则输出 ans 时，\(k^{len}\)一定大于n。（ √ ）
判断 1,2间上图样例 1,2，举例即可
判断 3: n转化为 len 位的 k 进制数字值 最大值为 \(k^{len} - 1\) ，因此 \(k^{len} > n\)。
单选题
4)若输入的n等于：\(10^15\)，输入的 k 为 1，则输出等于（ D ）。
A. \(1\)
B. \((10^{30}-10^{15})/2\)
C. \((10^{30}+10^{15})/2\)
D. \(10^{15}\)
5)若输入的 n 等于205,891,132,094,649（即 \(3^{30}\)），输入的 k 为 3，则输出等于（ B ）。
A. \(3^{30}\)
B. \((3^{30}-1)/2\)
C. \(3^{30}-1\)
D. \((3^{30}+1)/2\)
6)若输入的 n 等于 100,010,002,000,090，输入的 k 为 10，则输出等于（ D ）。
A. 11,112,222,444,543
B. 11,122,222,444,453
C. 11,122,222,444,543
D. 11,112,222,444,453
第 18 题(本题共 14.5 分)
1. #include <algorithm>
2. #include <iostream>
3. using namespace std;
5. int n;
6. int d[50][2];
7. int ans;
9. void dfs(int n, int sum) {
10. if (n == 1) {
11. ans = max(sum, ans);
12. return;
13. }
14. for (int i = 1; i < n; ++i) {
15. int a = d[i - 1][0], b = d[i - 1][1];
16. int x = d[i][0], y = d[i][1];
17. d[i - 1][0] = a + x;
18. d[i - 1][1] = b + y;
19. for (int j = i; j < n - 1; ++j)
20. d[j][0] = d[j + 1][0], d[j][1] = d[j + 1][1];
21. int s = a + x + abs(b - y);
22. dfs(n - 1, sum + s);
23. for (int j = n - 1; j > i; --j)
24. d[j][0] = d[j - 1][0], d[j][1] = d[j - 1][1];
25. d[i - 1][0] = a, d[i - 1][1] = b;
26. d[i][0] = x, d[i][1] = y;
27. }
28. }
30. int main() {
31. cin >> n;
32. for (int i = 0; i < n; ++i)
33. cin >> d[i][0];
34. for (int i = 0; i < n;++i)
35. cin >> d[i][1];
36. ans = 0;
37. dfs(n, 0);
38. cout << ans << endl;
39. return 0;
40. }
假设输入的n是不超过50的正整数，d[i][0]、d[i][i]都是不超过10000的正整数，完成下面的判断题和单选题：
判断题
1） 若输入 n 为 0,此程序可能会死循环或发生运行错误。（ x ）
2） 若输入 n 为 20,接下来的输入全为 0，则输出为 0。（ √ ）
3） 输出的数一定不小于输入的 d[i][0] 和 d[i][l] 的任意一个。（ x ）
单选题
4） 若输入的 n 为 20,接下来的输入是 20 个 9 和 20 个 0,则输出为（ B ）。
A. 1890
B. 1881
C. 1908
D. 1917
5） 若输入的 n 为 30,接下来的输入是 30 个 0 和 30 个 5,则输出为（ C ）。
A. 2000
B. 2010
C. 2030
D. 2020
6） （4分）若输入的 n 为 15，接下来的输入是 15 到 1，以及 15到1，则输出为（ C ）。
A. 2440
B. 2220
C. 2240
D. 2420
三、完善程序
（单选题，每小题 3 分，共计 30 分）
第 19 题(本题共 15 分)
1.（质因数分解）给出正整数 n，请输出将 n 质因数分解的结果，结果从小到大输出。 例如：输入 n=120，程序应该输出 2 2 2 3 5，表示：120 = 2 × 2 × 2 × 3 × 5。输入保证 2≤n≤10^9。
提示：先从小到大枚举变量 i，然后用 i 不停试除 n来寻找所有的质因子。
试补全程序。
1. #include <cstdio>
2. using namespace std;
3. int n, i;
5. int main() {
6. scanf("d", &n);
7. for(i = ①; ② <=n; i ++){
8. ③{
9. printf("%d ", i);
10. n = n / i;
11. }
12. }
13. if(④)
14. printf("%d ", ⑤);
15. return 0;
16. }
1）①处应填（ C ）
A. 1
B. n-1
C. 2
D. 0
2）②处应填（ C ）
A. n/i
B. n/(i*i)`` C. iiD.ii*i`
3）③处应填（ C )
A. n/i
B. n/(i*i)`` C. iiD.ii*i`
4）④处应填（ A ）
A. n/i
B. n/(i*i)
C. i*i
D. i*i*i
5）⑤处应填（ C )
A. 2
B. n/i
C. n
D. i
解析：
质数的判断是：for(int i=2; i*i<=n; i++){}
不停试除，直到结果不能被i整除：while(n%i==0){}
最后如果 n<=1那么结果就没必要输出，所以：if(n>1){ cout<<n; }
第 20 题(本题共 15 分)
（最小区间覆盖）给出 n 个区间，第 i 个区间的左右端点是 [a[i],b[i]]。现在要在这些区间中选出若干个，使得区间 [0, m] 被所选区间的并覆盖（即每一个 0≤i≤m 都在某个所选的区间中）。保证答案存在，求所选区间个数的最小值。
输入第一行包含两个整数 n 和 m （1≤n≤5000,1≤m≤10^9）接下来n行，每行两个整数
提示：使用贪心法解决这个问题。先用 O(n^2) 的时间复杂度排序，然后贪心选择这些区间。
试补全程序。
#include <iostream>
using namespace std;
const int MAXN = 5000;
int n, m;
struct segment {int a, b;} A[MAXN];
void sort() { // 排序
for (int i = 0; i < n; i++)
for (int j = 1; j < n; j++)
if (①) {
segment t = A[j];
②
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> A[i].a >> A[i]?b;
sort();
int p = 1;
for (int i = 1; i < n; i++)
if (③)
A[p++] = A[i];
n = p;
int ans =0, r = 0;
int q = 0;
while (r < m) {
while (④)
q++;
⑤;
ans++;
}
cout << ans << endl;
return 0;
}
1)①处应填（ B ）
A. A[j].b>A[j-1].b
B. A[j].a<A[j-1].a
C. A[j].a>A[j-1].a
D. A[j].b<A[j-1].b
2)②处应填（ D ）
A. A[j+1]=A[j];A[j]=t;
B. A[j-1]=A[j];A[j]=t;
C. A[j]=A[j+1];A[j+1]=t;
D. A[j]=A[j-1];A[j-1]=t;
3)③处应填（ A ）
A. A[i].b>A[p-1].b
B. A[i].b<A[i-1].b
C. A[i].b>A[i-1].b
D. A[i].b<A[p-1].b
4)④处应填（ A ）
A. A[i].b>A[p-1].b
B. A[i].b<A[i-1].b
C. A[i].b>A[i-1].b
D. A[i].b<A[p-1].b
5)⑤处应填（ B ）
A. A[i].b>A[p-1].b
B. A[i].b<A[i-1].b
C. A[i].b>A[i-1].b
D. A[i].b<A[p-1].b
解析：
-
按照 a 的大小升序排序，也就是保证： A[j-1].a <= A[j].a
所以：if(A[j-1].a > A[j].a) swap(A[j-1], A[j]); -
交换2个数据的方式：
int t = a; a = b; b = t; -
将下一个区间放入，但是放入的要求是：A[i].b 大于已放入的最右边，也就是
A[i].b>A[p-1].b -
区间个数肯定不能超过n，并且即将放入的模块的右区间的值一定要完成重合或者连接，不能出现空格现象，所以：
q+1<n&&A[q+1].a<=r -
最后对右边区间取最大值，表示已经覆盖到某个点了：
r=max(r,A[q].b)
