一、单项选择题（1~15 题，每题 2 分，共 30 分）

1. 在内存储器中每个存储单元都被赋予一个唯一的序号，称为（ ）。 {{ select(1) }}

• 地址
• 序号
• 下标
• 编号

2. 编译器的主要功能是（ ）。 {{ select(2) }}

• 将源程序翻译成机器指令代码
• 将源程序重新组合
• 将低级语言翻译成高级语言
• 将一种高级语言翻译成另一种高级语言

3. 设 x = true，y = true，z = false，以下逻辑运算表达式值为真的是（ ）。 {{ select(3) }}

• (y∨z)∧x∧z
• x∧(z∨y)∧z
• (x∧y)∧z
• (x∧y)∨(z∨x)

4. 现有一张分辨率为 2048×1024 像素的 32 位真彩色图像。请问要存储这张图像，需要多大的存储空间？（ ） {{ select(4) }}

• 16MB
• 4MB
• 8MB
• 32MB

5. 冒泡排序算法的伪代码如下： 输入：数组 L，n ≥ 1。输出：按非递减顺序排序的 L。 算法 BubbleSort：
6. FLAG ← n // 标记被交换的最后元素位置
7. while FLAG > 1 do

8. k ← FLAG - 1
   

9. FLAG ← 1
   

10. for j = 1 to k do
    

11.     if L(j) > L(j+1) then do
    

12.         L(j) ↔ L(j+1)
    

13.         FLAG ← j
    

对 n 个数用以上冒泡排序算法进行排序，最少需要比较多少次？（ ） {{ select(5) }}

• n²
• n-2
• n-1
• n

6. 设 A 是 n 个实数的数组，考虑下面的递归算法： XYZ(A[1..n])

1. if n=1 then return A[1]
2. else temp ← XYZ(A[1..n-1])

3. if temp < A[n]
   

4. then return temp
   

5. else return A[n]
   

请问算法 XYZ 的输出是什么？（ ） {{ select(6) }}

• 数组的平均
• 数组的最小值
• 数组的中值
• 数组的最大值

7. 链表不具有的特点是（ ）。 {{ select(7) }}

• 可随机访问任一元素
• 不必事先估计存储空间
• 插入删除不需要移动元素
• 所需空间与线性表长度成正比

8. 有 10 个顶点的无向图至少应该有（ ）条边才能确保是一个连通图。 {{ select(8) }}

• 9
• 10
• 11
• 12

9. 二进制数 1011 转换成十进制数是（ ） {{ select(9) }}

• 11
• 10
• 13
• 12

10. 五个小朋友并排站成一列，其中有两个小朋友是双胞胎，如果要求这两个双胞胎必须相邻，则有（ ）种不同排列方法？ {{ select(10) }}

• 48
• 36
• 24
• 72

11. 下图中所使用的数据结构是（ ）。 {{ select(11) }}

• 栈
• 队列
• 二叉树
• 哈希表

12. 独根树的高度为 1。具有 61 个结点的完全二叉树的高度为（ ）。 {{ select(12) }}

• 7
• 8
• 5
• 6

13. 干支纪年法是中国传统的纪年方法，由 10 个天干和 12 个地支组合成 60 个天干地支。由公历年份可以根据以下公式和表格换算出对应的天干地支。 天干 =（公历年份）除以 10 所得余数 地支 =（公历年份）除以 12 所得余数 例如，今年是 2020 年，2020 除以 10 余数为 0，查表为“庚”；2020 除以 12，余数为 4，查表为“子”，所以今年是庚子年。 请问 1949 年的天干地支是（ ） {{ select(13) }}

• 己酉
• 己亥
• 己丑
• 己卯

14. 10 个三好学生名额分配到 7 个班级，每个班级至少有一个名额，一共有（ ）种不同的分配方案。 {{ select(14) }}

• 84
• 72
• 56
• 504

15. 有五副不同颜色的手套（共 10 只手套，每副手套左右手各 1 只），一次性从中取 6 只手套，请问恰好能配成两副手套的不同取法有（ ）种。 {{ select(15) }}

• 120
• 180
• 150
• 30

二、阅读程序（判断题正确填 √、错误填 ×；判断题每题 1.5 分，选择题每题 3 分）

程序 1

 1 | #include <cstdlib>
 2 | #include <iostream>
 3 | using namespace std;
 4 | char encoder[26] = {'C', 'S', 'P', 0};
 5 |     char decoder[26];
 6 |     string st;
 7 |     int main() {
 8 |         int k = 0;
 9 |         for (int i = 0; i < 26; ++i)
10 |             if (encoder[i] != 0) ++k;
11 |                 for (char x = 'A'; x <= 'Z'; ++x) {
12 |                     bool flag = true;
13 |                     for (int i = 0; i < 26; ++i)
14 |                         if (encoder[i] == x) {
15 |                             flag = false;
16 |                             break;
17 |                         }
18 |                         if (flag) {
19 |                             encoder[k] = x;
20 |                             ++k;
21 |                         }
22 |                 }
23 |                 for (int i = 0; i < 26; ++i)
24 |                     decoder[encoder[i] - 'A'] = i + 'A';
25 |         cin >> st;
26 |         for (int i = 0; i < st.length(); ++i)
27 |             st[i] = decoder[st[i] - 'A'];
28 |         cout << st;
29 |         return 0;
30 |     }

16. 输入的字符串应当只由大写字母组成，否则在访问数组时可能越界。（ ） {{ select(16) }}

• 正确
• 错误

17. 若输入的字符串不是空串，则输入的字符串与输出的字符串一定不一样。（ ） {{ select(17) }}

• 正确
• 错误

18. 将第 12 行的“i < 26”改为“i < 16”，程序运行结果不会改变。（ ） {{ select(18) }}

• 正确
• 错误

19. 将第 26 行的“i < 26”改为“i < 16”，程序运行结果不会改变。（ ） {{ select(19) }}

• 正确
• 错误

20. 若输出的字符串为“ABCABCABCA”，则下列说法正确的是（ ） {{ select(20) }}

• 输入的字符串中既有S又有P
• 输入的字符串中既有S又有B
• 输入的字符串中既有A又有P
• 输入的字符串中既有A又有B

21. 若输出的字符串为“CSPCSPCSPCSP”，则下列说法正确的是（ ） {{ select(21) }}

• 输入的字符串中既有P又有K
• 输入的字符串中既有J又有R
• 输入的字符串中既有J又有K
• 输入的字符串中既有P又有R

程序 2

 1 | #include <iostream>
 2 | using namespace std;
 3 | // 假设输入的 n 是不超过 2^62 的正整数，k 都是不超过 10000 的正整数。
 4 | long long n, ans;
 5 | int k, len;
 6 | long long d[1000000];
 7 | int main() {
 8 |     cin >> n >> k;
 9 |     d[0] = 0;
10 |     len = 1;
11 |     ans = 0;
12 |     for (long long i = 0; i < n; ++i) {
13 |         ++d[0];
14 |         for (int j = 0; j + 1 < len; ++j) {
15 |             if (d[j] == k) {
16 |                 d[j] = 0;
17 |                 d[j + 1] += 1;
18 |                 ++ans;
19 |             }
20 |         }
21 |         if (d[len - 1] == k) {
22 |             d[len - 1] = 0;
23 |             d[len] = 1;
24 |             ++len;
25 |             ++ans;
26 |         }
27 |     }
28 |     cout << ans << endl;
29 |     return 0;
30 | }

22. 若 k=1，则输出 ans 时，len = n。（ ） {{ select(22) }}

• 正确
• 错误

23. 若 k>1，则输出 ans 时，len 一定小于 n。（ ） {{ select(23) }}

• 正确
• 错误

24. 若 k>1，则输出 ans 时，k^len 一定大于 n。（ ） {{ select(24) }}

• 正确
• 错误

25. 若输入的 n 等于 1015，输入的 k 为 1，则输出等于（ ） {{ select(25) }}

• 1
• (1030-1015)/2
• (1030+1015)/2
• 1015

26. 若输入的 n 等于 205,891,132,094,649（即 3^30），输入的 k 为 3，则输出等于（ ） {{ select(26) }}

• 330
• (330-1)/2
• 330-1
• (330+1)/2

27. 若输入的 n 等于 100,010,002,000,090，输入的 k 为 10，则输出等于（ ） {{ select(27) }}

• 11,112,222,444,543
• 11,122,222,444,453
• 11,122,222,444,543
• 11,112,222,444,453

程序 3

 1 | #include <algorithm>
 2 | #include <iostream>
 3 | using namespace std;
 4 | // 假设输入的 n 是不超过 50 的正整数，d[i][0]、d[i][1] 都是不超过 10000 的正整数。
 5 | int n;
 6 | int d[50][2];
 7 | int ans;
 8 | void dfs(int n, int sum) {
 9 |     if (n == 1) {
10 |         ans = max(sum, ans);
11 |         return;
12 |     }
13 |     for (int i = 1; i < n; ++i) {
14 |         int a = d[i - 1][0], b = d[i - 1][1];
15 |         int x = d[i][0], y = d[i][1];
16 |         d[i - 1][0] = a + x;
17 |         d[i - 1][1] = b + y;
18 |         for (int j = i; j < n - 1; ++j)
19 |             d[j][0] = d[j + 1][0], d[j][1] = d[j + 1][1];
20 |         int s = a + x + abs(b - y);
21 |         dfs(n - 1, sum + s);
22 |         for (int j = n - 1; j > i; --j)
23 |             d[j][0] = d[j - 1][0], d[j][1] = d[j - 1][1];
24 |         d[i - 1][0] = a, d[i - 1][1] = b;
25 |         d[i][0] = x, d[i][1] = y;
26 |     }
27 | }
28 | int main() {
29 |     cin >> n;
30 |     for (int i = 0; i < n; ++i)
31 |         cin >> d[i][0];
32 |     for (int i = 0; i < n; ++i)
33 |         cin >> d[i][1];
34 |     ans = 0;
35 |     dfs(n, 0);
36 |     cout << ans << endl;
37 |     return 0;
38 | }

28. 若输入 n 为 0，此程序可能会死循环或发生运行错误。（ ） {{ select(28) }}

• 正确
• 错误

29. 若输入 n 为 20，接下来的输入全为 0，则输出为 0。（ ） {{ select(29) }}

• 正确
• 错误

30. 输出的数一定不小于输入的 d[i][0] 和 d[i][1] 的任意一个。（ ） {{ select(30) }}

• 正确
• 错误

31. 若输入的 n 为 20，接下来的输入是 20 个 9 和 20 个 0，则输出为（ ） {{ select(31) }}

• 1890
• 1881
• 1908
• 1917

32. 若输入的 n 为 30，接下来的输入是 30 个 0 和 30 个 5，则输出为（ ） {{ select(32) }}

• 2000
• 2010
• 2030
• 2020

33. 若输入的 n 为 15，接下来的输入是 15 到 1，以及 15 到 1，则输出为（ ） {{ select(33) }}

• 2440
• 2220
• 2240
• 2420

三、完善程序（每题 3 分）

程序 1

 1 | #include <cstdio>
 2 | using namespace std;
 3 | int n, i;
 4 | int main() {
 5 |     scanf("%d", &n);
 6 |     for (i = ①; ② <= n; i ++) {
 7 |         ③ {
 8 |             printf("%d ", i);
 9 |             n = n / i;
10 |         }
11 |     }
12 |     if (④)
13 |         printf("%d ", ⑤);
14 |     return 0;
15 | }

34. （质因数分解）给出正整数 n，请输出将 n 质因数分解的结果，结果从小到大输出。例如：输入 n=120，程序应该输出 2 2 2 3 5，表示：120 = 2 × 2 × 2 × 3 × 5。输入保证 2<= n <= 10^9。提示：先从小到大枚举变量 i，然后用 i 不停试除 n 来寻找所有的质因子。 ①处应填（ ） {{ select(34) }}

• 1
• n-1
• 2
• 0

35. （质因数分解）给出正整数 n，请输出将 n 质因数分解的结果，结果从小到大输出。例如：输入 n=120，程序应该输出 2 2 2 3 5，表示：120 = 2 × 2 × 2 × 3 × 5。输入保证 2<= n <= 10^9。提示：先从小到大枚举变量 i，然后用 i 不停试除 n 来寻找所有的质因子。 ②处应填（ ） {{ select(35) }}

• n / i
• n / (i * i)
• i * i
• i * i * i

36. （质因数分解）给出正整数 n，请输出将 n 质因数分解的结果，结果从小到大输出。例如：输入 n=120，程序应该输出 2 2 2 3 5，表示：120 = 2 × 2 × 2 × 3 × 5。输入保证 2<= n <= 10^9。提示：先从小到大枚举变量 i，然后用 i 不停试除 n 来寻找所有的质因子。 ③处应填（ ） {{ select(36) }}

• if (n % i == 0)
• if (i * i <= n)
• while (n % i == 0)
• while (i * i <= n)

37. （质因数分解）给出正整数 n，请输出将 n 质因数分解的结果，结果从小到大输出。例如：输入 n=120，程序应该输出 2 2 2 3 5，表示：120 = 2 × 2 × 2 × 3 × 5。输入保证 2<= n <= 10^9。提示：先从小到大枚举变量 i，然后用 i 不停试除 n 来寻找所有的质因子。 ④处应填（ ） {{ select(37) }}

• n > 1
• n <= 1
• i < n / i
• i + i <= n

38. （质因数分解）给出正整数 n，请输出将 n 质因数分解的结果，结果从小到大输出。例如：输入 n=120，程序应该输出 2 2 2 3 5，表示：120 = 2 × 2 × 2 × 3 × 5。输入保证 2<= n <= 10^9。提示：先从小到大枚举变量 i，然后用 i 不停试除 n 来寻找所有的质因子。 ⑤处应填（ ） {{ select(38) }}

• 2
• n / i
• n
• i

程序 2

 1 | #include <algorithm>
 2 | #include <iostream>
 3 | using namespace std;
 4 | const int MAXN = 5000;
 5 | int n, m;
 6 | struct segment { int a, b; } A[MAXN];
 7 |     void sort() // 排序
 8 |     {
 9 |         for (int i = 0; i < n; i++)
10 |             for (int j = 1; j < n; j++)
11 |                 if (①) {
12 |                     segment t = A[j];
13 |                     ②
14 |                 }
15 |     }
16 |     int main()
17 |     {
18 |         cin >> n >> m;
19 |         for (int i = 0; i < n; i++)
20 |             cin >> A[i].a >> A[i].b;
21 |         sort();
22 |         int p = 1;
23 |         for (int i = 1; i < n; i++)
24 |             if (③)
25 |                 A[p++] = A[i];
26 |         n = p;
27 |         int ans = 0, r = 0;
28 |         int q = 0;
29 |         while (r < m) {
30 |             while (④)
31 |                 q++;
32 |             ⑤;
33 |             ans++;
34 |         }
35 |         cout << ans << endl;
36 |         return 0;
37 |     }

39. （最小区间覆盖）给出 n 个区间，第 i 个区间的左右端点是 [ai,bi]。现在要在这些区间中选出若干个，使得区间 [0, m] 被所选区间的并覆盖（即每一个 0≤i≤m 都在某个所选的区间中）。保证答案存在，求所选区间个数的最小值。 ①处应填（ ） {{ select(39) }}

• A[j].b > A[j-1].b
• A[j].a < A[j-1].a
• A[j].a > A[j-1].a
• A[j].b < A[j-1].b

40. （最小区间覆盖）给出 n 个区间，第 i 个区间的左右端点是 [ai,bi]。现在要在这些区间中选出若干个，使得区间 [0, m] 被所选区间的并覆盖（即每一个 0≤i≤m 都在某个所选的区间中）。保证答案存在，求所选区间个数的最小值。 ②处应填（ ） {{ select(40) }}

• A[j+1] = A[j]; A[j] = t;
• A[j-1] = A[j]; A[j] = t;
• A[j] = A[j+1]; A[j+1] = t;
• A[j] = A[j-1]; A[j-1] = t;

41. （最小区间覆盖）给出 n 个区间，第 i 个区间的左右端点是 [ai,bi]。现在要在这些区间中选出若干个，使得区间 [0, m] 被所选区间的并覆盖（即每一个 0≤i≤m 都在某个所选的区间中）。保证答案存在，求所选区间个数的最小值。 ③处应填（ ） {{ select(41) }}

• A[i].b > A[p-1].b
• A[i].b < A[i-1].b
• A[i].b > A[i-1].b
• A[i].b < A[p-1].b

42. （最小区间覆盖）给出 n 个区间，第 i 个区间的左右端点是 [ai,bi]。现在要在这些区间中选出若干个，使得区间 [0, m] 被所选区间的并覆盖（即每一个 0≤i≤m 都在某个所选的区间中）。保证答案存在，求所选区间个数的最小值。 ④处应填（ ） {{ select(42) }}

• q+1 < n && A[q+1].a <= r
• q+1 < n && A[q+1].b <= r
• q < n && A[q].a <= r
• q < n && A[q].b <= r

43. （最小区间覆盖）给出 n 个区间，第 i 个区间的左右端点是 [ai,bi]。现在要在这些区间中选出若干个，使得区间 [0, m] 被所选区间的并覆盖（即每一个 0≤i≤m 都在某个所选的区间中）。保证答案存在，求所选区间个数的最小值。 ⑤处应填（ ） {{ select(43) }}

• r = max(r, A[q+1].b)
• r = max(r, A[q].b)
• r = max(r, A[q+1].a)
• q++