CSP-J 2020 · 入门级第一轮真题

在内存储器中每个存储单元都被赋予一个唯一的序号，称为（ ）。

编译器的主要功能是（ ）。

设 x = true，y = true，z = false，以下逻辑运算表达式值为真的是（ ）。

现有一张分辨率为 $2048\times1024$ 像素的 $32$ 位真彩色图像。请问要存储这张图像，需要多大的存储空间？（ ）

冒泡排序算法的伪代码如下：

输入：数组 $L$，$n\ge 1$。输出：按非递减顺序排序的 $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$ 个实数的数组，考虑下面的递归算法：

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 的输出是什么？（ ）

链表不具有的特点是（ ）。

有 $10$ 个顶点的无向图至少应该有（ ）条边才能确保是一个连通图。

二进制数 $1011$ 转换成十进制数是（ ）。

$5$ 个小朋友并排站成一列，其中有两个小朋友是双胞胎，如果要求这两个双胞胎必须相邻，则有（ ）种不同排列方法。

下图中所使用的数据结构是（ ）。图示依次执行“压入 A、压入 B、弹出 B、压入 C”。

独根树的高度为 $1$。具有 $61$ 个结点的完全二叉树的高度为（ ）。

干支纪年法是中国传统的纪年方法，由 $10$ 个天干和 $12$ 个地支组合成 $60$ 个天干地支。由公历年份可以根据以下公式和表格换算出对应的天干地支。

天干＝（公历年份）除以 $10$ 所得余数

地支＝（公历年份）除以 $12$ 所得余数

例如，今年是 $2020$ 年，$2020$ 除以 $10$ 余数为 $0$，查表为“庚”；$2020$ 除以 $12$，余数为 $4$，查表为“子”，所以今年是庚子年。

请问 $1949$ 年的天干地支是（ ）。

$10$ 个三好学生名额分配到 $7$ 个班级，每个班级至少有一个名额，一共有（ ）种不同的分配方案。

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

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  #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$ 的正整数，完成下面的判断题和单选题。

1  #include <algorithm>
2  #include <iostream>
3  using namespace std;
4 
5  int n;
6  int d[50][2];
7  int ans;
8 
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  }
29 
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][1] 都是不超过 $10000$ 的正整数，完成下面的判断题和单选题。

（质因数分解）给出正整数 $n$，请输出将 $n$ 质因数分解的结果，结果从小到大输出。

例如：输入 n=120，程序应该输出 2 2 2 3 5，表示 $120=2\times2\times2\times3\times5$。输入保证 $2\le n\le10^9$。提示：先从小到大枚举变量 i，然后用 i 不停试除 n 来寻找所有的质因子。

试补全程序。

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

（最小区间覆盖）给出 $n$ 个区间，第 $i$ 个区间的左右端点是 $[a_i,b_i]$。现在要在这些区间中选出若干个，使得区间 $[0,m]$ 被所选区间的并覆盖（即每一个 $0\le i\le m$ 都在某个所选的区间中）。保证答案存在，求所选区间个数的最小值。

输入第一行包含两个整数 $n$ 和 $m$（$1\le n\le5000$，$1\le m\le10^9$）。

接下来 $n$ 行，每行两个整数 $a_i$、$b_i$（$0\le a_i,b_i\le m$）。

提示：使用贪心法解决这个问题。先用 $\Theta(n^2)$ 的时间复杂度排序，然后贪心选择这些区间。

试补全程序。

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