信奥刷题站
CSP-S 初赛2023-09

2023年 CSP-S 第一轮(提高级)

题量
43 题
客观题
43 题
建议时长
120 分钟
卷面总分
100 分
开始整卷模拟计时作答 · 交卷即时判分 · 错题自动进错题本(需登录)

// questions

题目预览

单项选择题
1
单选题2

在 Linux 系统终端中,以下哪个命令用于创建一个新的目录?

A

create

B

mkfolder

C

newdir

D

mkdir

2
单选题2

0,1,2,3,40,1,2,3,40,1,2,3,4 中选取 444 个数字,能组成( )个不同四位数。(注:最小的四位数是 100010001000,最大的四位数是 999999999999

A

181818

B

120120120

C

848484

D

969696

3
单选题2

假设 nnn 是图的顶点的个数,mmm 是图的边的个数,为求解某一问题有下面四种不同时间复杂度的算法。对于 m=Θ(n)m=\Theta(n)m=Θ(n) 的稀疏图而言,下面的四个选项,哪一项的渐近时间复杂度最小。

A

O(n2+m)\mathrm{O}(n^2+m)O(n2+m)

B

O(n2log⁡m+mlog⁡n)\mathrm{O}(\frac{n^2}{\log{m}}+m\log{n})O(logmn2+mlogn)

C

O(m+nlog⁡n)\mathrm{O}(m+n\log{n})O(m+nlogn)

D

O(mlog⁡n×log⁡log⁡n)\mathrm{O}(m\sqrt{\log{n} \times \log{\log{n}}})O(mlogn×loglogn)

4
单选题2

假设有 nnn 根柱子,需要按照以下规则依次放置编号为 1,2,3,...1, 2, 3,...1,2,3,... 的圆环:每根柱子的底部固定,顶部可以放入圆环,每次从柱子顶部放入圆环时,需要保证任何两个相邻圆环的编号之和是一个完全平方数。请计算当有 444 根柱子时,最多可以放置( )个圆环。

A

999

B

777

C

555

D

111111

5
单选题2

以下对数据结构的表述不恰当的一项是:( )。

A

散列表是一种通过散列函数将关键字映射到存储位置的数据结构

B

二叉树是一种每个结点最多有两个子结点的树结构

C

队列是一种先进先出(FIFO)的线性结构

D

哈夫曼树的构造过程主要是为了实现图的深度优先搜索

6
单选题2

以下连通无向图中,( )一定可以用不超过两种颜色进行染色

A

完全三叉树

B

平面图

C

边双连通图

D

欧拉图

7
单选题2

最长公共子序列长度常常用来衡量两个序列的相似度。其定义如下:给定两个序列 X={x1,xz,x3,...,xm}X=\{x_1,x_z,x_3,...,x_m\}X={x1,xz,x3,...,xm} 和 Y={yi,yz,y3,...,yn}Y=\{y_i,y_z,y_3,...,y_n\}Y={yi,yz,y3,...,yn}, 最长公共子序列(LCS)问题的目标是找到一个最长的新序列 Z={z1,z2,z3,...,zk}Z=\{z_1,z_2,z_3,...,z_k\}Z={z1,z2,z3,...,zk} 使得序列 ZZZ 既是序列 XXX 的子序列,又是序列 YYY 的子序列,且序列 ZZZ 的长度 kkk 在满足上述条件的序列里是最大的。(注: 序列 AAA 是序列 BBB 的子序列,当且仅当在保持序列 BBB 元素顺序的情况下,从序列 BBB 中删除若干个元素,可以使得剩余的元素构成序列 AAA。)则序列 ABCAAAABAABABCBABA 的最长公共子序列长度为( )

A

555

B

777

C

444

D

666

8
单选题2

一位玩家正在玩一个特殊的掷骰子的游戏,游戏要求连续掷两次骰子,收益规则如下: 玩家第一次掷出 xxx 点,得到 2x2x2x 元;第二次掷出 yyy 点,当 y=xy=xy=x 时玩家会失去之前得到的 2x2x2x 元而当 y≠xy\neq xy=x 时玩家能保住第一次获得的2x2x2x 元。上述 x,y∈{1,2,3,4,5,6}x,y\in \{1,2,3,4,5,6\}x,y{1,2,3,4,5,6}。例如: 玩家第一次掷出 333 点得到 666 元后,但第二次再次掷出 333 点,会失去之前得到的 666 元,玩家最终收益为 000 元;如果玩家第一次掷出 333 点、第二次掷出 444 点,则最终收益是 666 元。假设骰子挑出任意一点的概率均为 16\frac{1}{6}61,玩家连续掷两次骰子后,所有可能情形下收益的平均值是多少?

A

163\frac{16}{3}316

B

193\frac{19}{3}319

C

777

D

356\frac{35}{6}635

9
单选题2

假设我们有以下的 C++ 代码:

int a = 5, b = 3, c = 4;
bool res = a & b || c ^ b && a | c;

请问,res 的值是什么? ( )

提示:在 C++ 中,逻辑运算的优先级从高到低依次为:逻辑非(!)、逻辑与(&&)、逻辑或(||)。位运算的优先级从高到低依次为:位非(~)、位与(&)、位异或(^)、位或 (|)。同时,双目位运算的优先级高于双目逻辑运算;逻辑非和位非优先级相同,且高于所有双目运算符。

A

false

B

1

C

0

D

true

10
单选题2

假设快速排序算法的输入是一个长度为 nnn 的已排序数组,且该快速排序算法在分治过程总是选择第一个元素作为基准元素。以下哪个选项描述的是在这种情况下的快速排序行为?

A

快速排序无法对此类数组进行排序,因为数组已经排序

B

快速排序对于此类输入的表现最好,因为数组已经排序

C

快速排序对于此类输入的时间复杂度是 O(nlog⁡n)\mathrm{O}(n\log{n})O(nlogn)

D

快速排序对于此类输入的时间复杂度是 O(n2)\mathrm{O}(n^2)O(n2)

11
单选题2

以下哪个命令,能将一个名为 main.cpp 的 C++ 源文件,编译并生成一个名为 main 的可执行文件?( )

A

g++ -o main.cpp main

B

g++ main -o main.cpp

C

g++ main.cpp -o main.cpp

D

g++ -o main main.cpp

12
单选题2

在图论中,树的重心是树上的一个结点,以该结点为根时,使得其所有的子树中结点数最多的子树的结点数最少。一棵树可能有多个重心。请问下面哪种树一定只有一个重心?

A

666 个结点的树

B

888 个结点的树

C

444 个结点的树

D

777 个结点的树

13
单选题2

[图片]

如图是一张包含 666 个顶点的有向图,但顶点间不存在拓扑序。如果要删除其中一条边,使这 666 个顶点能进行拓扑排序,请问总共有多少条边可以作为候选的被删除边?

A

222

B

444

C

111

D

333

14
单选题2

n=Σi=0k16i⋅xin = \Sigma^{k}_{i=0}16^i·{x_i}n=Σi=0k16ixi,定义 f(n)=Σi=0kxi\mathrm{f}(n) = \Sigma^{k}_{i=0}x_if(n)=Σi=0kxi;其中 xi∈0,1,…,15x_i\in {0,1,\dots,15}xi0,1,,15。对于给定自然数 n0n_0n0,存在序列 n0,n1,n2,…,nmn_0, n_1, n_2,\dots,n_mn0,n1,n2,,nm,其中对于 1≤i≤m1\leq i \leq m1im 都有 ni=f(ni−1)n_i = \mathrm{f}(n_{i-1})ni=f(ni1),且 nm=nm−1n_m=n_{m-1}nm=nm1,称 nmn_mnmn0n_0n0 关于 f\mathrm{f}f 的不动点。问在 10016100_{16}100161A016\mathrm{1A0}_{16}1A016 中,关于 f\mathrm{f}f 的不动点为 999 的自然数个数为( )。

A

121212

B

131313

C

101010

D

111111

15
单选题2

现在用如下代码来计算 xnx^nxn,其时间复杂度为( )。

double quick_power(double x, unsigned n) {
    if (n == 0) return 1;
    if (n == 1) return x;
    return quick_power(x, n / 2)
        * quick_power(x, n / 2)
        * ((n & 1) ? x : 1);
}
A

O(1)\mathrm{O}(1)O(1)

B

O(log⁡n)\mathrm{O}(\log{n})O(logn)

C

O(nlog⁡n)\mathrm{O}(n\log{n})O(nlogn)

D

O(n)\mathrm{O}(n)O(n)

阅读程序
16
判断题1
阅读程序代码(共 16-21 题共用)
#include <iostream>
using namespace std;

unsigned short f(unsigned short x) {
    x ^= x << 6;
    x ^= x >> 8;
    return x;
}

int main() {
    unsigned short x;
    cin >> x;
    unsigned short y = f(x);
    cout << y << endl;
    return 0;
}

假设输入的 x 是不超过 655356553565535 的自然数,完成下面的判断题。

当输入非零时,输出一定不为零。

A

错误

B

正确

17
判断题2

假设输入的 x 是不超过 655356553565535 的自然数,完成下面的判断题。

将f函数的输入参数的类型改为 unsigned int,程序的输出不变。

A

正确

B

错误

18
判断题1

假设输入的 x 是不超过 655356553565535 的自然数,完成下面的判断题。

当输入为 65535 时,输出为 63

A

错误

B

正确

19
判断题1

假设输入的 x 是不超过 655356553565535 的自然数,完成下面的判断题。

当输入为 1 时,输出为 64

A

正确

B

错误

20
单选题3

假设输入的 x 是不超过 655356553565535 的自然数,完成下面的单选题。

当输入为 512 时,输出为( )

A

33106

B

33346

C

33280

D

33410

21
单选题3

假设输入的 x 是不超过 655356553565535 的自然数,完成下面的单选题。

当输入为 64 时,执行完第 5 行后 x 的值为( )

A

4130

B

4128

C

8256

D

4160

22
判断题1
阅读程序代码(共 22-27 题共用)
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;

long long solve1(int n) {
    vector<bool> p(n + 1, true);
    vector<long long> f(n + 1, 0), g(n + 1, 0);
    f[1] = 1;
    for (int i = 2; i * i <= n; i++) {
        if (p[i]) {
            vector<int> d;
            for (int k = i; k <= n; k *= i) d.push_back(k);
            reverse(d.begin(), d.end());
            for (int k : d) {
                for(int j = k; j <= n; j += k){
                    if(p[j]){
                        p[j] = false;
                        f[j] = i;
                        g[j] = k;
                    }
                }
            }
        }
    }
    for (int i = sqrt(n) + 1; i <= n; i++) {
        if (p[i]) {
            f[i] = i;
            g[i] = i;
        }
    }
    long long sum = 1;
    for (int i = 2; i <= n; i++) {
        f[i] = f[i / g[i]] * (g[i] * f[i] - 1) / (f[i] - 1);
        sum += f[i]; 
    }
    return sum; 
}

long long solve2(int n) {
    long long sum = 0;
    for(int i = 1; i <= n; i++){
        sum += i * (n / i);
    }
    return sum;
}

int main() {
    int n;
    cin >> n;
    cout << solve1(n) << endl;
    cout << solve2(n) << endl;
    return 0;
}

假设输入的 n 是不超过 100000010000001000000 的自然数,完成下面的判断题。

将第 15 行删去,输出不变。

A

正确

B

错误

23
判断题1

假设输入的 n 是不超过 100000010000001000000 的自然数,完成下面的判断题。

当输入为 10 时,输出的第一行大于第二行。

A

正确

B

错误

24
判断题2

假设输入的 n 是不超过 100000010000001000000 的自然数,完成下面的判断题。

当输入为 1000 时,输出的第一行与第二行相等。

A

错误

B

正确

25
单选题3

假设输入的 n 是不超过 100000010000001000000 的自然数,完成下面的单选题。

solve1(n) 的时间复杂度为( )

A

O(n)\mathrm{O}(n)O(n)

B

O(nlog⁡n)\mathrm{O}(n\log{n})O(nlogn)

C

O(nlog⁡2n)\mathrm{O}(n\log^{2}n)O(nlog2n)

D

O(nlog⁡log⁡n)\mathrm{O}(n\log{\log{n}})O(nloglogn)

26
单选题3

假设输入的 n 是不超过 100000010000001000000 的自然数,完成下面的单选题。

solve2(n) 的时间复杂度为( )

A

O(nlog⁡n)\mathrm{O}(n\log{n})O(nlogn)

B

O(n2)\mathrm{O}(n^2)O(n2)

C

O(nn)\mathrm{O}(n\sqrt n)O(nn)

D

O(n)\mathrm{O}(n)O(n)

27
单选题3

假设输入的 n 是不超过 100000010000001000000 的自然数,完成下面的单选题。

输入为 5 时,输出的第二行为( )

A

22

B

23

C

20

D

21

28
判断题1
阅读程序代码(共 28-33 题共用)
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

bool f0(vector<int>& a, int m, int k) {
    int s = 0;
    for (int i = 0, j = 0; i < a.size(); i++) {
        while (a[i] - a[j] > m) j++;
        s += i - j;
    }
    return s >= k; 
}

int f(vector<int>& a, int k) {
    sort(a.begin(), a.end());
    
    int g = 0;
    int h = a.back() - a[0];
    while (g < h) {
        int m = g + (h - g) / 2;
        if (f0(a, m, k)) {
            h = m;
        } else {
            g = m + 1;
        }
    }
    
    return g;
}

int main() {
    int n, k;
    cin >> n >> k;
    vector<int> a(n, 0);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    cout << f(a, k) << endl;
    return 0;
}

假设输入总是合法的且 ∣a[i]∣≤108,n≤10000|a[i]| \leq 10^8, n\leq 10000a[i]108,n100001≤k≤n(n−1)21\leq k \leq \frac{n(n-1)}{2}1k2n(n1),完成下面的判断题。

将第 24 行的 m 改为 m - 1,输出有可能不变,而剩下情况为少 111

A

错误

B

正确

29
判断题1

假设输入总是合法的且 ∣a[i]∣≤108,n≤10000|a[i]| \leq 10^8, n\leq 10000a[i]108,n100001≤k≤n(n−1)21\leq k \leq \frac{n(n-1)}{2}1k2n(n1),完成下面的判断题。

将第 22 行的 g +(h - g) / 2 改为(h + g) >> 1,输出不变。

A

错误

B

正确

30
判断题1

假设输入总是合法的且 ∣a[i]∣≤108,n≤10000|a[i]| \leq 10^8, n\leq 10000a[i]108,n100001≤k≤n(n−1)21\leq k \leq \frac{n(n-1)}{2}1k2n(n1),完成下面的判断题。

当输入为 5 7 2 -4 5 1 -3,输出为 5

A

错误

B

正确

31
单选题3

假设输入总是合法的且 ∣a[i]∣≤108,n≤10000|a[i]| \leq 10^8, n\leq 10000a[i]108,n100001≤k≤n(n−1)21\leq k \leq \frac{n(n-1)}{2}1k2n(n1),完成下面的单选题。

a 数组中最大值减最小值加 111AAA,则 f 函数的时间复杂度为( )。

A

O(n2log⁡A)\mathrm{O}(n^2\log A)O(n2logA)

B

O(nlog⁡n)\mathrm{O}(n\log n)O(nlogn)

C

O(nlog⁡A)\mathrm{O}(n\log A)O(nlogA)

D

O(nlog⁡(nA))\mathrm{O}(n\log(nA))O(nlog(nA))

32
单选题3

假设输入总是合法的且 ∣a[i]∣≤108,n≤10000|a[i]| \leq 10^8, n\leq 10000a[i]108,n100001≤k≤n(n−1)21\leq k \leq \frac{n(n-1)}{2}1k2n(n1),完成下面的单选题。

将第 10 行中的 > 替换为 >=,那么原输出与现输出的大小关系为( )。

A

一定小于

B

一定大于等于且不一定大于

C

以上三种情况都不对

D

一定小于等于且不一定小于

33
单选题3

假设输入总是合法的且 ∣a[i]∣≤108,n≤10000|a[i]| \leq 10^8, n\leq 10000a[i]108,n100001≤k≤n(n−1)21\leq k \leq \frac{n(n-1)}{2}1k2n(n1),完成下面的单选题。

当输入为 5 8 2 -5 3 8 -12 时,输出为( )。

A

8

B

15

C

13

D

14

完善程序
34
单选题3
阅读程序代码(共 34-38 题共用)
#include <algorithm>
#include <algorithm>
#include <vector>

const int MAXN = 100000;
const long long LIM = 1000000000000000000LL;

int n, m, deg[MAXN];
std::vector<int> E[MAXN];
long long k, f[MAXN];

int next(std::vector<int> cand, long long &k) {
    std::sort(cand.begin(), cand.end());
    for (int u : cand) {
        if (①) return u;
        k -= f[u];
    }
    return -1;
}

int main() {
    std::cin >> n >> m >> k;
    for (int i=0; i<m; ++i) {
        int u, v;
        std::cin >> u >> v;
        E[u].push_back(v);
        ++deg[v];
    }
    std::vector<int> Q;
    for (int i=0; i<n; ++i)
        if (!deg[i]) Q.push_back(i);
    for (int i=0; i<n; ++i) {
        int u= Q[i];
        for (int v : E[u]) {
            if (②) Q.push_back(v);
            --deg[v];
        }
    }
    std::reverse(Q.begin(), Q.end());
    for (int u: Q) {
        f[u] = 1;
        for (int v : E[u]) f[u] = ③;
    }
    int u = next(Q, k);
    std::cout << u << std::endl;
    while (④) {
        ⑤;
        u = next(E[u], k);
        std::cout << u << std::endl;
    }
    return 0;
}

(第k小路径)给定一张 nnn 个点 mmm 条边的有向无环图,顶点编号从 000n−1n-1n1

对于一条路径,我们定义“路径序列”为该路径从起点出发依次经过的项点编号构成的序列。求所有至少包含一个点的简单路径中,“路径序列”字典序第 kkk 小的路径。保证存在至少 kkk 条路径。上述参数满足 1≤n,m≤1051\leq n,m\leq 10^51n,m1051≤k≤10181\leq k\leq 10^{18}1k1018

在程序中,我们求出从每个点出发的路径数量。超过101810^{18}1018 的数都用 101810^{18}1018 表示。然后我们根据 kkk 的值和每个顶点的路径数量,确定路径的起点,然后可以类似地依次求出路径中的每个点。

试补全程序。

① 处应该填 ( )

A

k > f[u]

B

k < f[u]

C

k >= f[u]

D

k <= f[u]

35
单选题3

(第k小路径)给定一张 nnn 个点 mmm 条边的有向无环图,顶点编号从 000n−1n-1n1

对于一条路径,我们定义“路径序列”为该路径从起点出发依次经过的项点编号构成的序列。求所有至少包含一个点的简单路径中,“路径序列”字典序第 kkk 小的路径。保证存在至少 kkk 条路径。上述参数满足 1≤n,m≤1051\leq n,m\leq 10^51n,m1051≤k≤10181\leq k\leq 10^{18}1k1018

在程序中,我们求出从每个点出发的路径数量。超过101810^{18}1018 的数都用 101810^{18}1018 表示。然后我们根据 kkk 的值和每个顶点的路径数量,确定路径的起点,然后可以类似地依次求出路径中的每个点。

试补全程序。

② 处应该填 ( )

A

deg[v] == 1

B

deg[v] == 0

C

deg[v] > 1

D

deg[v] > 0

36
单选题3

(第k小路径)给定一张 nnn 个点 mmm 条边的有向无环图,顶点编号从 000n−1n-1n1

对于一条路径,我们定义“路径序列”为该路径从起点出发依次经过的项点编号构成的序列。求所有至少包含一个点的简单路径中,“路径序列”字典序第 kkk 小的路径。保证存在至少 kkk 条路径。上述参数满足 1≤n,m≤1051\leq n,m\leq 10^51n,m1051≤k≤10181\leq k\leq 10^{18}1k1018

在程序中,我们求出从每个点出发的路径数量。超过101810^{18}1018 的数都用 101810^{18}1018 表示。然后我们根据 kkk 的值和每个顶点的路径数量,确定路径的起点,然后可以类似地依次求出路径中的每个点。

试补全程序。

③ 处应该填 ( )

A

std::min(f[u] + f[v], LIM)

B

std::min(f[u] + f[v] + 1, LIM)

C

std::min(f[u] * f[v], LIM)

D

std::min(f[u] * (f[v] + 1), LIM)

37
单选题3

(第k小路径)给定一张 nnn 个点 mmm 条边的有向无环图,顶点编号从 000n−1n-1n1

对于一条路径,我们定义“路径序列”为该路径从起点出发依次经过的项点编号构成的序列。求所有至少包含一个点的简单路径中,“路径序列”字典序第 kkk 小的路径。保证存在至少 kkk 条路径。上述参数满足 1≤n,m≤1051\leq n,m\leq 10^51n,m1051≤k≤10181\leq k\leq 10^{18}1k1018

在程序中,我们求出从每个点出发的路径数量。超过101810^{18}1018 的数都用 101810^{18}1018 表示。然后我们根据 kkk 的值和每个顶点的路径数量,确定路径的起点,然后可以类似地依次求出路径中的每个点。

试补全程序。

④ 处应该填 ( )

A

!E[u].empty()

B

k > 0

C

u != -1

D

k > 1

38
单选题3

(第k小路径)给定一张 nnn 个点 mmm 条边的有向无环图,顶点编号从 000n−1n-1n1

对于一条路径,我们定义“路径序列”为该路径从起点出发依次经过的项点编号构成的序列。求所有至少包含一个点的简单路径中,“路径序列”字典序第 kkk 小的路径。保证存在至少 kkk 条路径。上述参数满足 1≤n,m≤1051\leq n,m\leq 10^51n,m1051≤k≤10181\leq k\leq 10^{18}1k1018

在程序中,我们求出从每个点出发的路径数量。超过101810^{18}1018 的数都用 101810^{18}1018 表示。然后我们根据 kkk 的值和每个顶点的路径数量,确定路径的起点,然后可以类似地依次求出路径中的每个点。

试补全程序。

⑤ 处应该填 ( )

A

k -= f[u]

B

++k

C

k += f[u]

D

--k

39
单选题3
阅读程序代码(共 39-43 题共用)
#include <iostream>
#include <algorithm>
#include <vector>

const int MAXN = 100000;
int n;
int a[MAXN];
long long ans;

void solve(int l, int r) {
    if (l + 1 == r) {
        ans += a[l];
        return ;
    }
    int mid = (l + r) >> 1;
    std::vector<int> pre(a + mid, a + r);
    for (int i = 1; i < r - mid; ++i) ①;
    std::vector<long long> sum(r - mid + 1);
    for (int i = 0; i < r - mid; ++i) sum[i + 1] = sum[i] + pre[i];
    for (int i = mid - 1, j = mid, max = 0; i >= l; --i) {
        while (j < r && ②) ++j;
        max = std::max(max, a[i]);
        ans += ③;
        ans += ④;
    }
    solve(l, mid);
    solve(mid, r);
}

int main() {
    std::cin >> n;
    for (int i = 0; i < n; ++i) std::cin >> a[i];
    ⑤;
    std::cout << ans << std::endl;
    return 0;
}

(最大值之和)给定整数序列 a0,...,an−1a_0, ..., a_{n-1}a0,...,an1 求该序列所有非空连续子序列的最大值之和。上述参数满足 1<n≤1051 <n\leq 10^51<n1051≤ai≤1081\leq a_i \leq 10^81ai108

一个序列的非空连续子序列可以用两个下标 lllrrr (其中 0≤l≤r<n0\leq l\leq r<n0lr<n) 表示,对应的序列为 al,al+1,...,ara_l, a_{l+1}, ..., a_ral,al+1,...,ar。两个非空连续子序列不同,当且仅当下标不同。

例如,当原序列为 [1,2,1,2] 时,要计算子序列 [1][2][1][2][1,2][2,1][1,2][1,2,1][2,1,2][1,2,1,2] 的最大值之和,答案为 181818。 注意 [1,1][2,2] 虽然是原序列的子序列,但不是连续子序列,所以不应该被计算。另外,注意其中有一些值相同的子序列,但由于他们在原序列中的下标不同,属于不同的非空连续子序列,所以会被分别计算。

解决该问题有许多算法,以下程序使用分治算法,时间复杂度 O(nlog⁡n)\mathrm{O}(n \log n)O(nlogn)

试补全程序。

① 处应填( )

A

pre[i + 1] = std::max(pre[i], pre[i + 1])

B

pre[i] = std::max(pre[i - 1], a[i])

C

pre[i] = std::max(pre[i - 1], a[i - 1])

D

pre[i] = std::max(pre[i], pre[i - 1])

40
单选题3

(最大值之和)给定整数序列 a0,...,an−1a_0, ..., a_{n-1}a0,...,an1 求该序列所有非空连续子序列的最大值之和。上述参数满足 1<n≤1051 <n\leq 10^51<n1051≤ai≤1081\leq a_i \leq 10^81ai108

一个序列的非空连续子序列可以用两个下标 lllrrr (其中 0≤l≤r<n0\leq l\leq r<n0lr<n) 表示,对应的序列为 al,al+1,...,ara_l, a_{l+1}, ..., a_ral,al+1,...,ar。两个非空连续子序列不同,当且仅当下标不同。

例如,当原序列为 [1,2,1,2] 时,要计算子序列 [1][2][1][2][1,2][2,1][1,2][1,2,1][2,1,2][1,2,1,2] 的最大值之和,答案为 181818。 注意 [1,1][2,2] 虽然是原序列的子序列,但不是连续子序列,所以不应该被计算。另外,注意其中有一些值相同的子序列,但由于他们在原序列中的下标不同,属于不同的非空连续子序列,所以会被分别计算。

解决该问题有许多算法,以下程序使用分治算法,时间复杂度 O(nlog⁡n)\mathrm{O}(n \log n)O(nlogn)

试补全程序。

② 处应填( )

A

pre[j - mid] > max

B

a[j] < max

C

pre[j - mid] < max

D

a[j] < a[i]

41
单选题3

(最大值之和)给定整数序列 a0,...,an−1a_0, ..., a_{n-1}a0,...,an1 求该序列所有非空连续子序列的最大值之

和。上述参数满足 1<n≤1051 <n\leq 10^51<n1051≤ai≤1081\leq a_i \leq 10^81ai108

一个序列的非空连续子序列可以用两个下标 lllrrr (其中 0≤l≤r<n0\leq l\leq r<n0lr<n) 表示,对应的序列为 al,al+1,...,ara_l, a_{l+1}, ..., a_ral,al+1,...,ar。两个非空连续子序列不同,当且仅当下标不同。

例如,当原序列为 [1,2,1,2] 时,要计算子序列 [1][2][1][2][1,2][2,1][1,2][1,2,1][2,1,2][1,2,1,2] 的最大值之和,答案为 181818。 注意 [1,1][2,2] 虽然是原序列的子序列,但不是连续子序列,所以不应该被计算。另外,注意其中有一些值相同的子序列,但由于他们在原序列中的下标不同,属于不同的非空连续子序列,所以会被分别计算。

解决该问题有许多算法,以下程序使用分治算法,时间复杂度 O(nlog⁡n)\mathrm{O}(n \log n)O(nlogn)

试补全程序。

③ 处应填( )

A

(long long)(j - mid) * max

B

(long long)(j - mid) * (i - 1) * max

C

sum[j - mid]

D

sum[j - mid] * (i - 1)

42
单选题3

(最大值之和)给定整数序列 a0,...,an−1a_0, ..., a_{n-1}a0,...,an1 求该序列所有非空连续子序列的最大值之

和。上述参数满足 1<n≤1051 <n\leq 10^51<n1051≤ai≤1081\leq a_i \leq 10^81ai108

一个序列的非空连续子序列可以用两个下标 lllrrr (其中 0≤l≤r<n0\leq l\leq r<n0lr<n) 表示,对应的序列为 al,al+1,...,ara_l, a_{l+1}, ..., a_ral,al+1,...,ar。两个非空连续子序列不同,当且仅当下标不同。

例如,当原序列为 [1,2,1,2] 时,要计算子序列 [1][2][1][2][1,2][2,1][1,2][1,2,1][2,1,2][1,2,1,2] 的最大值之和,答案为 181818。 注意 [1,1][2,2] 虽然是原序列的子序列,但不是连续子序列,所以不应该被计算。另外,注意其中有一些值相同的子序列,但由于他们在原序列中的下标不同,属于不同的非空连续子序列,所以会被分别计算。

解决该问题有许多算法,以下程序使用分治算法,时间复杂度 O(nlog⁡n)\mathrm{O}(n \log n)O(nlogn)

试补全程序。

④ 处应填( )

A

(long long)(r - j) * (mid - i) * max

B

(sum[r - mid] - sum[j - mid]) * (mid - i)

C

(long long)(r - j) * max

D

sum[r - mid] - sum[j - mid]

43
单选题3

(最大值之和)给定整数序列 a0,...,an−1a_0, ..., a_{n-1}a0,...,an1 求该序列所有非空连续子序列的最大值之

和。上述参数满足 1<n≤1051 <n\leq 10^51<n1051≤ai≤1081\leq a_i \leq 10^81ai108

一个序列的非空连续子序列可以用两个下标 lllrrr (其中 0≤l≤r<n0\leq l\leq r<n0lr<n) 表示,对应的序列为 al,al+1,...,ara_l, a_{l+1}, ..., a_ral,al+1,...,ar。两个非空连续子序列不同,当且仅当下标不同。

例如,当原序列为 [1,2,1,2] 时,要计算子序列 [1][2][1][2][1,2][2,1][1,2][1,2,1][2,1,2][1,2,1,2] 的最大值之和,答案为 181818。 注意 [1,1][2,2] 虽然是原序列的子序列,但不是连续子序列,所以不应该被计算。另外,注意其中有一些值相同的子序列,但由于他们在原序列中的下标不同,属于不同的非空连续子序列,所以会被分别计算。

解决该问题有许多算法,以下程序使用分治算法,时间复杂度 O(nlog⁡n)\mathrm{O}(n \log n)O(nlogn)

试补全程序。

⑤ 处应填( )

A

solve(0, n)

B

solve(0, n - 1)

C

solve(1, n)

D

solve(1, n - 1)