GESP 客观题评测系统

试卷解析 · 理解每一步

2023 洛谷 SCP-J 第一轮模拟题(入门级 C++)

CSPJ-2023-R1-Mock-Luogu

试卷解析总览,可直接查看每题答案与解析。

一、单项选择题

(共 15 题,每题 2 分,共计 30 分;每题有且仅有一个正确选项)

第 1 题(单选题,2 分)

网址 `www.luogu.com.cn` 当中,顶级域名是( )。

A.
`www`
B.
`cn`
C.
`com.cn`
D.
`luogu`

正确答案B

解析详情
答案 B域名层级
思路与推导
  1. 域名从右向左层级升高,`www.luogu.com.cn` 最右侧的 `cn` 是国家和地区顶级域名,因此选择 B。

第 2 题(单选题,2 分)

以下物品可以携带进 CSP 第二轮测试考场的是( )。

A.
可以发出巨大响声的发光机械键盘
B.
写有 kkksc03 签名的《深入浅出程序设计竞赛 基础篇》的封皮
C.
印有 dzd 照片(已设法获得其授权)的文化衫 T 恤
D.
具有拍照功能的游标卡尺

正确答案C

解析详情
答案 C竞赛考场规则
思路与推导
  1. 普通文化衫不属于电子设备或书籍资料,且照片已经获得授权,因此 C 可以携带;会干扰考场、含资料内容或带拍照功能的物品均不合规。

第 3 题(单选题,2 分)

将元素 `a,b,c,d,e,f` 依次入栈,则以下选项中出栈序列不可能是( )。

A.
`b,d,c,f,e,a`
B.
`f,e,d,c,b,a`
C.
`d,c,e,b,f,a`
D.
`d,c,f,b,e,a`

正确答案D

解析详情
答案 D栈的出栈序列
思路与推导
  1. D 中先弹出 `d,c` 后,若再压入并弹出 `f`,`e` 仍位于 `b` 上方,不可能接着弹出 `b`,所以该序列无法产生。

第 4 题(单选题,2 分)

“流程结构”是编程中用于控制程序执行流程的一种方式,它包括顺序结构、分支结构和循环结构。在一些诗歌作品中,也有对“流程结构”的体现。下列诗歌片段中体现循环结构的是( )。

A.
如果还能找到你,就让风儿告诉你。——《Artificial Emotions》
B.
只要我还能够行走,只要我还能够张望,只要我还能够呼吸,就一直走向前方。——《Песня отревожной молодости》
C.
昔闻洞庭水,今上岳阳楼。——《登岳阳楼》
D.
啊如果我在,战斗中牺牲,啊朋友再见吧,再见吧,再见吧!如果我在,战斗中牺牲,你一定把我来埋葬。——《Bella Ciao》

正确答案B

解析详情
答案 B循环结构
思路与推导
  1. B 用多个“只要”描述持续条件,并以“就一直走向前方”描述条件成立时重复执行的动作,体现循环结构。

第 5 题(单选题,2 分)

已知两个二进制整数 a,ba,b:a=10100010102a=1010001010_2,b=11101001102b=1110100110_2,则表达式 `(a & b) ^ (a | b)` 的值为( )。

A.
001101101020011011010_2
B.
010010110020100101100_2
C.
001101001020011010010_2
D.
010010100020100101000_2

正确答案B

解析详情
答案 B位运算恒等式
思路与推导
  1. 对每一位都有 `(a & b) ^ (a | b) = a ^ b`;逐位异或得到 `0100101100`,对应 B。

第 6 题(单选题,2 分)

一个有 10 个结点的有向图,要使得每一个满足 1≤i,j≤101\le i,j\le10、i≠ji\ne j 的点对 (i,j)(i,j) 都存在一条从 ii 到达 jj 的路径,至少需要连( )条有向边。

A.
9
B.
10
C.
19
D.
20

正确答案B

解析详情
答案 B强连通有向图
思路与推导
  1. 每个结点至少要有一条出边,10 个结点至少需要 10 条边;用 10 条边构成一个有向环即可让任意结点互相可达。

第 7 题(单选题,2 分)

观察下列代码,其中 `k` 的类型以及 `k` 的值分别为( )。

int a[] = {5, 4, 3, 2, 1};
auto p = a + 3;
auto q = &p;
(*q) ++;
auto k = *p;
A.
`int` 类型,值为 1
B.
`int` 类型,值为 3
C.
`int` 指针类型,值为 `a` 数组的下标为 3 的元素的地址
D.
`int` 指针类型,值为 `a` 数组的下标为 4 的元素的地址

正确答案A

解析详情
答案 A指针与 auto
思路与推导
  1. 初始 `p=a+3`,`q` 指向变量 `p`;`(*q)++` 把 `p` 移到 `a+4`,所以 `k=*p=a[4]=1`,且 `k` 推导为 `int`。

第 8 题(单选题,2 分)

中缀表达式 `a+(b+c)-d*e/f` 改写成后缀表达式为( )。

A.
a b + c + d e * f / -
B.
a b c + + d e * f / -
C.
a b + c + d * e f / -
D.
a b c + + d * e / f -

正确答案B

解析详情
答案 B后缀表达式
思路与推导
  1. 先把 `(b+c)` 写成 `b c +`,再处理 `a+...` 和 `d*e/f`,最终为 `a b c + + d e * f / -`。

第 9 题(单选题,2 分)

一张大小为 6114×81926114\times8192 的 24 位彩色图片,使用 `.bmp` 格式存储,占用的空间大小约为( )。

A.
144 MiB
B.
288 MiB
C.
1152 MiB
D.
48 MiB

正确答案A

解析详情
答案 A位图存储空间
思路与推导
  1. 24 位即每像素 3 字节,空间约为 6114×8192×3/220≈143.36114×8192×3/2^{20}≈143.3 MiB,取约数为 144 MiB。

第 10 题(单选题,2 分)

以下程序片段的时间复杂度为( )。

int cnt = 0;
for(int i = 1; i <= n; i++) {
    for(int j = 1; j <= n; j += i) {
        for(int k = 1; k <= n; k += j) {
            ++cnt;
        }
    }
}

提示:

$n11+n21+⋯+nn1≈C1log⁡n,\frac n{1^1}+\frac n{2^1}+\cdots+\frac n{n^1}\approx C_1\log n,$

$n12+n22+⋯+nn2≈C2,\frac n{1^2}+\frac n{2^2}+\cdots+\frac n{n^2}\approx C_2,$

其中 C1,C2C_1,C_2 均为常数。

A.
Θ(n2)\Theta(n^2)
B.
Θ(n2log⁡n)\Theta(n^2\log n)
C.
Θ(nlog⁡n)\Theta(n\log n)
D.
Θ(nlog⁡2n)\Theta(n\log^2 n)

正确答案A

解析详情
答案 A嵌套循环复杂度
思路与推导
  1. 对每个 `i`,`j=1` 时内层 `k` 都执行 nn 次,仅这一项总计已是 n2n^2;其余项总量不超过同阶,因此复杂度为 Θ(n²)。

第 11 题(单选题,2 分)

依次抛出四个六面骰子,按照抛出顺序将骰子上的数值记为 a,b,c,da,b,c,d。则 a<ba<b、b>cb>c、c<dc<d 同时成立的概率为( )。

A.
95/64895/648
B.
4/274/27
C.
5/275/27
D.
1/61/6

正确答案A

解析详情
答案 A离散概率计数
思路与推导
  1. 四个骰子共有 64=12966^4=1296 个等可能结果;按中间值 `b,c` 枚举,满足 a<ba<b 且 c<min(b,d)c<min(b,d) 的结果共有 190 个,概率为 190/1296=95/648190/1296=95/648。

第 12 题(单选题,2 分)

十进制小数 0.3,转写成八进制为( )。

A.
0.30.3
B.
0.2314631…0.2314631\ldots
C.
0.2046204…0.2046204\ldots
D.
0.3333333…0.3333333\ldots

正确答案B

解析详情
答案 B小数进制转换
思路与推导
  1. 反复乘 8 得到整数位序列 `2,3,1,4,6,3,1,...`,因此八进制表示为 `0.2314631...`。

第 13 题(单选题,2 分)

观察如下代码片段,其中 `sizeof(u)` 的值为( )。

union U {
    bool flag1, flag2, flag3, flag4, flag5;
    signed short a;
    unsigned short b;
    enum E {
        CardA = 0, CardB = 1,
        CardC = 2, CardD = 142857
    } e;
} u;
A.
4
B.
8
C.
13
D.
16

正确答案A

解析详情
答案 A联合体大小
思路与推导
  1. 联合体所有成员共享内存,大小由最大成员及对齐决定;枚举成员通常占 4 字节且对齐为 4,所以 `sizeof(u)=4`。

第 14 题(单选题,2 分)

已知某种可用来维护序列的数据结构,支持 Θ(log⁡n)\Theta(\log n) 向某个位置后面插入元素、Θ(n)\Theta(n) 查询某个元素的排名、Θ(nlog⁡n)\Theta(n\log n) 遍历整个序列,那么用上述三种操作实现插入排序的时间复杂度最坏为( )。

A.
Θ(n2)\Theta(n^2)
B.
Θ(n2log⁡n)\Theta(n^2\log n)
C.
Θ(nlog⁡n)\Theta(n\log n)
D.
Θ(nlog⁡2n)\Theta(n\log^2 n)

正确答案A

解析详情
答案 A插入排序复杂度
思路与推导
  1. 插入每个元素前需用 Θ(n) 查询排名,执行 nn 次得到 Θ(n²);插入和最终遍历的代价更低,不改变最坏阶。

第 15 题(单选题,2 分)

今年是 CCF(中国计算机学会)第( )次举办 CSP-J/S(计算机非专业级别的软件能力认证)?

A.
27
B.
28
C.
5
D.
4

正确答案C

解析详情
答案 CCSP-J/S 届次
思路与推导
  1. CSP-J/S 从 2019 年开始举办,2023 年依次是第 5 次,因此选择 C。

二、阅读程序(1)

 1 | #include <iostream>
 2 | #include <cstring>
 3 | using namespace std;
 4 | string s, t;
 5 | string a, b;
 6 | int main(){
 7 |     getline(cin, s);
 8 |     getline(cin, a);
 9 |     getline(cin, b);
10 |     for(int i = 0; i < s.size(); i++){
11 |         bool flag = true;
12 |         if(i + a.size() <= s.size()){
13 |             for(int j = 0; j < a.size(); j++){
14 |                 char p = s[i + j], q = a[j];
15 |                 if('a' <= p && p <= 'z') p = p - 'a' + 'A';
16 |                 if('a' <= q && q <= 'z') q = q - 'a' + 'A';
17 |                 if(p != q)
18 |                     flag = false;
19 |             }
20 |         } else
21 |             flag = false;
22 |
23 |         if(flag == true){
24 |             t += b;
25 |             i += a.size() - 1;
26 |         } else
27 |             t += s[i];
28 |     }
29 |     cout << t << endl;
30 |     return 0;
31 | }

保证输入的三行字符串的长度均不超过 10310^3,且每个字符串均由 ASCII 可视字符或空格组成且非空。完成下面的判断题和单选题。

第 16 题(判断题,2 分)

保持 `s,b` 的字母大小写不变,将 `a` 里的小写英文字母改写成大写、将大写英文字母改写成小写,输出结果不变。( )

正确答案正确

解析详情
答案 正确大小写无关匹配
思路与推导
  1. 比较时 `s` 和 `a` 中的小写字母都会临时转成大写,交换 `a` 的原始大小写不会改变任何匹配位置,输出不变。

第 17 题(判断题,2 分)

每次调用 `s.size()` 的复杂度是 O(1)O(1),但若把 `s.size()` 替换成 `s.length()`,则调用的复杂度将会变成 O(l)O(l),其中 ll 是 `s` 当前的长度。这是因为 `s.length()` 作为 `strlen()` 函数的 `string` 版本,会每次重新计算 `s` 最后一个元素的位置。( )

正确答案错误

解析详情
答案 错误string 长度接口
思路与推导
  1. `std::string::size()` 与 `length()` 语义等价,通常都直接返回已保存的长度,复杂度均为 O(1)O(1);`length()` 不是 `strlen()` 的逐次扫描包装。

第 18 题(判断题,2 分)

当输入的字符串 `s,a,b` 均由小写字母 `a` 或 `b` 组成,记 `s,a,b` 的长度分别为 n,m,kn,m,k,则程序的时间复杂度最坏为 O(nm+nk)O(nm+nk)。( )

正确答案正确

解析详情
答案 正确字符串替换复杂度
思路与推导
  1. 最坏情况下每个起点比较至多 mm 个字符,代价 O(nm)O(nm);向结果串追加替换串的总上界为 O(nk)O(nk),合计 O(nm+nk)O(nm+nk)。

第 19 题(判断题,2 分)

当输入的字符串 `s,a,b` 均由小写字母 `a` 组成,记 `s,a,b` 的长度分别为 n,m,kn,m,k 且有 n>m>kn>m>k,那么上述程序的总复杂度为 O(n)O(n)。( )

正确答案正确

解析详情
答案 正确匹配跳跃优化
思路与推导
  1. 全为 `a` 时每次成功匹配后 `i` 前进约 mm,只有约 n/mn/m 次完整比较,总代价 O(n)O(n);追加内容总量约 (n/m)k<n(n/m)k<n,仍为 O(n)O(n)。

第 20 题(单选题,3 分)

针对下列输入数据,程序的输出为( )。

National Olympiad in Informatics A154
A
C
A.
`National Olympiad in Informatics C154`
B.
`NCtionCl OlympiCd in InformCtics C154`
C.
`National!`
D.
`Nctioncl Olympicd in Informctics C154`

正确答案B

解析详情
答案 B不区分大小写替换
思路与推导
  1. 程序把 `National Olympiad in Informatics A154` 中所有 `a` 或 `A` 都替换为大写 `C`,得到 `NCtionCl OlympiCd in InformCtics C154`。

第 21 题(单选题,3 分)

针对下列输入数据,程序的输出为( )。

abaabaaabaaaabaaaaabababab
aa
ab
A.
`abABbABBbABBBbABBBBbababab`
B.
`ababbabbbabbbbabbbbbababab`
C.
`ababbababababbabababababab`
D.
程序陷入死循环或非正常退出,无法正常输出

正确答案C

解析详情
答案 C非重叠字符串替换
思路与推导
  1. 程序从左到右寻找 `aa`,成功后写入 `ab` 并跳过两个原字符;按此规则处理得到 `ababbababababbabababababab`。

二、阅读程序(2)

 1 | #include<iostream>
 2 | using namespace std;
 3 | int a[100005], b[100005], n, m;
 4 | void very_quick_sort(int l, int r, int p, int q){
 5 |     if(l >= r || p > q){   // ①
 6 |         return;
 7 |     }
 8 |     int mid = (l + r) / 2;
 9 |     int p0 = p - 1;
10 |     int q0 = q + 1;
11 |     for(int i = p; i <= q; i++){
12 |         if(a[i] > mid) b[++p0] = a[i];
13 |         else           b[--q0] = a[i];
14 |     }
15 |     for(int i = p; i <= q; i++)
16 |         a[i] = b[i];
17 |     very_quick_sort(mid + 1, r, p, p0);
18 |     very_quick_sort(l, mid, q0, q);
19 | }
20 | int main(){
21 |     cin >> n >> m;
22 |     for(int i = 1; i <= n; i++)
23 |         cin >> a[i];
24 |     very_quick_sort(1, m, 1, n);
25 |     // ②
26 |     for(int i = 1; i <= n; i++)
27 |         cout << a[i] << " ";
28 |     cout << endl;
29 |     return 0;
30 | }

保证输入的 nn 不超过 10510^5,mm 不超过 10910^9,且 1≤a1,a2,…,an≤m1\le a_1,a_2,\ldots,a_n\le m。完成下面的判断题和单选题。

第 22 题(判断题,1 分)

(1 分)上述代码实现了一种排序算法,可以将 `a` 数组按照从小到大的顺序排序。( )

正确答案错误

解析详情
答案 错误排序方向
思路与推导
  1. 划分时大于 `mid` 的值写到左侧,小于等于 `mid` 的值写到右侧,递归后数组按从大到小排列,因此题述“从小到大”错误。

第 23 题(判断题,2 分)

如果在程序开始之前向 `b` 数组里写入数据(保证不会发生数组越界),则上述代码的输出不会发生变化。( )

正确答案正确

解析详情
答案 正确辅助数组覆盖
思路与推导
  1. 每次处理非空区间 `p..q` 时,循环都会把 `b[p..q]` 全部重新写入,再复制回 `a`,所以 `b` 的初始内容不会影响输出。

第 24 题(判断题,2 分)

若 n=mn=m,存在某种数据构造方式,使得上述代码运行的时间复杂度为 O(n2)O(n^2),这是因为算法本身是对快速排序的改进,但是这种改进不能避免由于对数组的划分不够均等而在极端数据下导致复杂度发生退化。( )

正确答案错误

解析详情
答案 错误按值域二分排序
思路与推导
  1. 每次递归都把值域 `[l,r]` 对半,深度为 O(log m),每层总共扫描 nn 个元素;划分不会因数据偏斜退化为 O(n2)O(n^2)。

第 25 题(判断题,2 分)

如果将 ① 处的 `l >= r` 条件删除(同时删除 `||` 使得程序能正常编译运行,下同),程序的时间复杂度不会发生变化;而将 `p > q` 条件删除,程序在某些数据下的运行效率将会明显降低。( )

正确答案错误

解析详情
答案 错误递归终止条件
思路与推导
  1. 删除 `l>=r` 后,值域缩到单点且区间非空时会反复递归同一状态,不能正常终止,所以“复杂度不会变化”这一前提已经错误。

第 26 题(单选题,3 分)

不认为 n,mn,m 同阶,即可能出现 nn 远大于 mm 或者 mm 远大于 nn 的情况。则该程序的最坏时间复杂度为( )。

A.
Θ(n2+m2)\Theta(n^2+m^2)
B.
Θ(mlog⁡m)\Theta(m\log m)
C.
Θ(mlog⁡n)\Theta(m\log n)
D.
Θ(nlog⁡m)\Theta(n\log m)

正确答案D

解析详情
答案 D值域划分复杂度
思路与推导
  1. 递归深度为 Θ(log m),每一层所有区间合计处理 nn 个元素,因此最坏时间复杂度是 Θ(n log m)。

第 27 题(单选题,3 分)

若输入数据为:

10 10
10 4 5 2 2 3 1 5 8 3

那么在程序执行到 ② 位置时,`b` 数组内的值为( )。

A.
[10,8,3,5,1,3,2,2,5,4]
B.
[3,5,1,3,2,2,5,4,10,8]
C.
[10,8,5,5,4,3,3,2,2,1]
D.
[1,2,2,3,3,4,5,5,8,10]

正确答案C

解析详情
答案 C辅助数组最终状态
思路与推导
  1. 按值域递归完成后,数组被排成降序;最后一次划分写入 `b` 的完整结果为 `[10,8,5,5,4,3,3,2,2,1]`。

二、阅读程序(3)

 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <algorithm>
 4 | using namespace std;
 5 | const int mod = 1000000000 + 7;
 6 | int w0[100005];
 7 | int w1[100005];
 8 | int w2[100005];
 9 | int n, m, k, f[100005], d[100005], id[100005];
10 | vector <int> e[100005];
11 | void dfs(int u, int fa){
12 |     d[u] = d[fa] + 1;
13 |     f[u] = fa;
14 |
15 |     for(auto &v : e[u]) if(v != fa){
16 |         dfs(v, u);
17 |     }
18 | }
19 | bool cmp(int a, int b){
20 |     return d[a] < d[b];
21 | }
22 | int main(){
23 |     cin >> n >> m >> k;
24 |     for(int i = 2; i <= n; i++){
25 |         int u, v;
26 |         cin >> u >> v;
27 |         e[u].push_back(v);
28 |         e[v].push_back(u);
29 |     }
30 |     dfs(1, 0);                    // ①
31 |     for(int i = 1; i <= m; i++){
32 |         int x, w;
33 |         cin >> x >> w;
34 |         w1[x] = (w1[x] + w) % mod;
35 |         w2[x] = (w2[x] + w) % mod;
36 |     }
37 |     for(int i = 1; i <= n; i++)
38 |         id[i] = i;
39 |     sort(id + 1, id + 1 + n, cmp);
40 |     for(int i = 1; i <= k; i++){
41 |         for(int j = n; j >= 1; j--){
42 |             int x = id[j];
43 |             for(auto &y : e[x]) if(y != f[x]){
44 |                 w1[y] = (w1[y] + w1[x]) % mod;
45 |             }
46 |             w1[x] = 0;
47 |         }
48 |         for(int x = 1; x <= n; x++)
49 |             w1[x] = (w1[x] - w0[x] + mod) % mod,
50 |             w0[x] = 0;
51 |         for(int j = 1; j <= n; j++){ // ②
52 |             int x = id[j];
53 |             if(f[x]){
54 |                 w1[f[x]] = (w1[f[x]] + w2[x]) % mod;
55 |                 w2[f[x]] = (w2[f[x]] + w2[x]) % mod;
56 |                 w0[x] = (w0[x] + w2[x]) % mod;
57 |                 w2[x] = 0;
58 |             }
59 |         }
60 |     }
61 |     for(int i = 1; i <= n; i++)
62 |         cout << w1[i] << " ";
63 |     return 0;
64 | }

保证输入的 n,mn,m 不超过 10510^5,kk 不超过 20,且 1≤xi≤n1\le x_i\le n,0≤wi<109+70\le w_i<10^9+7。完成下面的判断题和单选题。

第 28 题(判断题,2 分)

如果更改 ① 处 `dfs(1, 0)` 为 `dfs(n, 0)`,则输出结果可能有变化。( )

正确答案错误

解析详情
答案 错误树上距离转移
思路与推导
  1. 程序的父子方向只服务于分层转移,向下传播、向上汇总和 `w0` 去重共同计算与根无关的树上距离信息;改根不会改变输出,因此“可能变化”错误。

第 29 题(判断题,1 分)

(1 分)如果 `k=n`,那么输出结果均为 0。( )

正确答案正确

解析详情
答案 正确树的最大距离
思路与推导
  1. 一棵有 nn 个结点的树中任意两点距离至多 n−1n-1;程序在第 `k` 轮保留距离为 `k` 的贡献,所以 `k=n` 时所有结果均为 0。

第 30 题(判断题,2 分)

如果更改 ② 处 `for(int j=1; j<=n; j++)` 为 `for(int j=n; j>=1; j--)`,那么对于任意合法的输入数据,更改前后程序的输出均相同。( )

正确答案错误

解析详情
答案 错误树上转移顺序
思路与推导
  1. 原循环按深度从浅到深处理,使 `w2` 每轮只向父亲移动一层;反向后某个值可能在同一轮连续传到祖先多层,输出会改变。

第 31 题(单选题,2 分)

(2 分)该程序的时间复杂度为( )。

A.
Θ(nmk)\Theta(nmk)
B.
Θ(nk+m)\Theta(nk+m)
C.
Θ(km+n)\Theta(km+n)
D.
Θ(n+m+2k)\Theta(n+m+2^k)

正确答案B

解析详情
答案 B树上算法复杂度
思路与推导
  1. 按题目答案的计量口径,读入和建树为 Θ(n+m),每轮三组遍历均为 Θ(n),共 `k` 轮得到 Θ(nk+m),选择 B。

第 32 题(单选题,3 分)

对于以下的输入数据,输出结果为( )。

5 2 1
1 2
2 3
3 4
3 5
1 5
3 2
A.
0 7 0 2 2
B.
2 7 2 3 2
C.
5 2 1 1 1
D.
0 2 1 1 2

正确答案A

解析详情
答案 A树上程序模拟
思路与推导
  1. 初始权值位于结点 1 的 5 和结点 3 的 2;完整执行一轮向下、去重和向上转移后,`w1[1..5]` 为 `0 7 0 2 2`。

第 33 题(单选题,3 分)

对于以下的输入数据,输出结果为( )。

9 9 2
1 2
1 7
2 3
2 4
7 8
4 5
4 6
8 9
1 1
2 10
3 100
4 1000
5 10000
6 100000
7 1000000
8 10000000
9 100000000
A.
10001100 1110000 1001 101 100010 10010 100000010 1 1000000
B.
0 0 1 1 10 10 0 1 1000000
C.
11001110 1111100 1001 110101 100010 10010 110000010 100000001 1000000
D.
11001111 1111112 1121 111121 112010 112010 111000012 112000001 121000000

正确答案A

解析详情
答案 A两轮树上转移
思路与推导
  1. 按深度顺序执行两轮转移,第一轮 `w1` 为 `1000010 1101 10 110010 1000 1000 10000001 101000000 10000000`,第二轮得到选项 A。

三、完善程序(1)

(序列问题)给定序列 ana_n,求有多少对 (i,j)(i,j) 满足 ai<aja_i<a_j。测试数据满足 n≤106n\le10^6,ai≤109a_i\le10^9。

提示:对于任意的 ai≠aja_i\ne a_j,可以发现 (i,j)(i,j) 或 (j,i)(j,i) 能对答案产生 1 的贡献,因此只需要用总的对数减去 ai=aja_i=a_j 的 (i,j)(i,j) 数量,就能得到答案。试补全程序。

#include<bits/stdc++.h>
using namespace std;
const int Maxn = ①;
int n, a[Maxn];
long long s[Maxn], ans;
bool check(int l, int r) {
    if (s[r] - s[l - 1] == ②) return true;
    return false;
}



int main() {
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    sort(a + 1, a + n + 1);
    for (int i = 1; i <= n; i++)
        s[i] = s[i - 1] + a[i];
    ans = ③;
    for (int i = 1; i <= n;) {
        int l = i, r = n, pos = n;
        while (④) {
            int mid = (l + r) >> 1;
            if(check(l, mid))
                l = mid + 1, pos = mid;
            else
                r = mid - 1;
        }
        ans -= ⑤;
        i = pos + 1;
    }
    cout << ans;
}

第 34 题(单选题,3 分)

① 处应填( )。

A.
1e6 + 7
B.
1000000
C.
1e6
D.
1000000000000

正确答案A

解析详情
答案 A数组容量
思路与推导
  1. 数组使用 1 到 `n` 的下标且 n≤106n≤10^6,容量必须大于 10610^6;`1e6 + 7` 留出边界空间,选择 A。

第 35 题(单选题,3 分)

② 处应填( )。

A.
(r - l + 1) * a[l]
B.
s[r] - s[l - 1]
C.
1LL * (r - l + 1) * a[l]
D.
a[1] = 0

正确答案C

解析详情
答案 C等值区间判定
思路与推导
  1. 排序后区间 `[l,r]` 全部等于 `a[l]` 当且仅当区间和等于 `1LL*(r-l+1)*a[l]`;`1LL` 防止乘法在 `int` 中溢出。

第 36 题(单选题,3 分)

③ 处应填( )。

A.
n * (n + 1) / 2
B.
1LL * n * (n + 1) / 2
C.
n * (n - 1) / 2
D.
1LL * n * (n - 1) / 2

正确答案D

解析详情
答案 D数对总数
思路与推导
  1. 不同下标组成的无序对总数为 n(n−1)/2n(n-1)/2,且 nn 可达 10610^6,应写成 `1LL * n * (n - 1) / 2`。

第 37 题(单选题,3 分)

④ 处应填( )。

A.
l < r
B.
l <= r
C.
l <= r + 1
D.
l > r

正确答案B

解析详情
答案 B二分边界
思路与推导
  1. 代码要检查包含单个元素的最后区间,标准闭区间二分条件是 `l <= r`,对应 B。

第 38 题(单选题,3 分)

⑤ 处应填( )。

A.
(pos - l + 1) * (pos - l) / 2
B.
1LL * (pos - l + 1) * (pos - l) / 2
C.
(pos - i + 1) * (pos - i) / 2
D.
1LL * (pos - i + 1) * (pos - i) / 2

正确答案D

解析详情
答案 D重复值数对
思路与推导
  1. 当前相等段从固定起点 `i` 到 `pos`,长度为 `pos-i+1`,需减去 L(L−1)/2L(L-1)/2;用 `1LL` 防溢出,故选择 D。

三、完善程序(2)

(异或和)给定序列 ana_n,求其所有子区间异或和的和。某个区间的异或和是将这个区间内的所有数字分别进行异或计算。其中 n≤105n\le10^5,0≤ai≤1090\le a_i\le10^9。

提示:对每一位独立计算,对右端点扫描线,并用异或前缀和辅助统计。试补全程序。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int n, a[N], cnt[2];
long long ans;
int main () {
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i], ①;
    for (int bit = ②; ③; bit--) {
        cnt[0] = cnt[1] = 0;
        for (int i = 0; i <= n; i++) {
            cnt[④]++;
            ans += 1LL * ⑤;
        }
    }
    cout << ans;
}

第 39 题(单选题,3 分)

① 处应填( )。

A.
a[i - 1] ^= a[i]
B.
a[i] ^= a[i - 1]
C.
a[i - 1] += a[i]
D.
a[i] += a[i - 1]

正确答案B

解析详情
答案 B异或前缀和
思路与推导
  1. 扫描输入时应令 `a[i] ^= a[i-1]`,使 `a[i]` 变成前 `i` 个数的异或前缀和,因此选择 B。

第 40 题(单选题,3 分)

② 处应填( )。

A.
n - 1
B.
29
C.
n
D.
n + 1

正确答案B

解析详情
答案 B二进制最高位
思路与推导
  1. ai≤109<230a_i≤10^9<2^{30},只需枚举第 29 位到第 0 位,所以循环初值为 29。

第 41 题(单选题,3 分)

③ 处应填( )。

A.
bit
B.
bit >= n
C.
bit - 1
D.
~bit

正确答案D

解析详情
答案 D位枚举终止
思路与推导
  1. `bit` 从 29 递减时,`~bit` 在 `bit>=0` 时非零;减到 -1 后 `~(-1)=0`,循环恰好结束,因此选择 D。

第 42 题(单选题,3 分)

④ 处应填( )。

A.
(a[i] >> bit) & 1
B.
a[i] & (1 << bit)
C.
a[i] & (1LL << bit)
D.
(a[i] >> bit) ^ 1

正确答案A

解析详情
答案 A提取单个二进制位
思路与推导
  1. 计数数组下标只能是 0 或 1,表达式 `(a[i] >> bit) & 1` 正好提取第 `bit` 位,选择 A。

第 43 题(单选题,3 分)

⑤ 处应填( )。

A.
cnt[(a[i] >> bit) & 1] << i
B.
cnt[(a[i] >> bit) & 1 ^ 1] << bit
C.
cnt[(a[i] >> bit) & 1] << bit
D.
cnt[(a[i] >> bit) & 1 ^ 1] << i

正确答案B

解析详情
答案 B子区间异或贡献
思路与推导
  1. 当前前缀第 `bit` 位为 `v` 时,只有此前位为 `v^1` 的前缀能产生该位为 1 的区间;贡献为 `cnt[v ^ 1] << bit`,对应 B。