cspj组2022年初赛

ID: 2831

Type: Objective

Tried: 1

Accepted: 0

Difficulty: 10

Uploaded By:

hantina

以下哪种功能没有涉及C++语言的面向对象特性支持：（）。{{ select(1) }}

A. C++中调用printf函数
B. C++中调用用户定义的类成员函数
C. C++中构造一个class或struct
D. C++中构造来源于同一基类的多个派生类

有6个元素，按照6、5、4、3、2、1的顺序进入栈S，请问下列哪个出栈序列是非法的（）。{{ select(2) }}

A. 5 4 3 6 1 2
B. 4 5 3 1 2 6
C. 3 4 6 5 2 1
D. 2 3 4 1 5 6

运行以下代码片段的行为是（）。

int x = 101;
int y = 201;
int *p = &x;
int *q = &y;
p = q;

A. 将x的值赋为201
B. 将y的值赋为101
C. 将q指向x的地址
D. 将p指向y的地址

链表和数组的区别包括（）。{{ select(4) }}

A. 数组不能排序，链表可以
B. 链表比数组能存储更多的信息
C. 数组大小固定，链表大小可动态调整
D. 以上均正确

对假设栈S和队列Q的初始状态为空。存在e1~e6六个互不相同的数据，每个数据按照进栈S、出栈S、进队列Q、出队列Q的顺序操作，不同数据间的操作可能会交错。已知栈S中依次有数据e1、e2、e3、e4、e5和e6进栈，队列Q依次有数据e2、e4、e3、e6、e5和e1出队列。则栈S的容量至少是（）个数据。{{ select(5) }}

A. 2
B. 3
C. 4
D. 6

对表达式a+(b-c)*d的前缀表达式为（），其中+、-、*是运算符。{{ select(6) }}

A. *+a-bcd
B. +a*-bcd
C. abc-d*+
D. abc-+d

假设字母表 {a, b, c, d, e} 在字符串出现的频率分别为 10%, 15%, 30%, 16%, 29%。若使用哈夫曼编码方式对字母进行不定长的二进制编码，字母d的编码长度为（）位。{{ select(7) }}

A. 1
B. 2
C. 2或3
D. 3

一棵有n个结点的完全二叉树用数组进行存储与表示，已知根结点存储在数组的第1个位置。若存储在数组第9个位置的结点存在兄弟结点和两个子结点，则它的兄弟结点和右子结点的位置分别是（）。{{ select(8) }}

A. 8、18
B. 10、18
C. 8、19
D. 10、19

考虑由N个顶点构成的有向连通图，采用邻接矩阵的数据结构表示时，该矩阵中至少存在（）个非零元素。{{ select(9) }}

A. N-1
B. N
C. N+1
D. N2

以下对数据结构的表述不恰当的一项为：（）。{{ select(10) }}

A. 图的深度优先遍历算法常使用的数据结构为栈。
B. 栈的访问原则为后进先出，队列的访问原则是先进先出。
C. 队列常常被用于广度优先搜索算法。
D. 栈与队列存在本质不同，无法用栈实现队列。

以下哪组操作能完成在双向循环链表结点p之后插入结点s的效果（其中，next域为结点的直接后继，prev域为结点的直接前驱）：（）。{{ select(11) }}

A. p->next->prev=s; s->prev=p; p->next=s; s->next=p->next;
B. p->next->prev=s; p->next=s; s->prev=p; s->next=p->next;
C. s->prev=p; s->next=p->next; p->next=s; p->next->prev=s;
D. s->next=p->next; p->next->prev=s; s->prev=p; p->next=s;

以下排序算法的常见实现中，哪个选项的说法是错误的：（）。{{ select(12) }}

A. 冒泡排序算法是稳定的
B. 简单选择排序是稳定的
C. 简单插入排序是稳定的
D. 归并排序算法是稳定的

八进制数32.1对应的十进制数是（）。{{ select(13) }}

A. 24.125
B. 24.250
C. 26.125
D. 26.250

一个字符串中任意个连续的字符组成的子序列称为该字符串的子串，则字符串abcab有（）个内容互不相同的子串。{{ select(14) }}

A. 12
B. 13
C. 14
D. 15

以下对递归方法的描述中，正确的是：（）{{ select(15) }}

A. 递归是允许使用多组参数调用函数的编程技术
B. 递归是通过调用自身来求解问题的编程技术
C. 递归是面向对象和数据而不是功能和逻辑的编程语言模型
D. 递归是将用某种高级语言转换为机器代码的编程技术

二、阅读程序

(1)

#include <iostream>
using namespace std;

int main()
{
    unsigned short x, y;
    cin >> x >> y;
    x = (x | x << 2) & 0x33;
    x = (x | x << 1) & 0x55;
    y = (y | y << 2) & 0x33;
    y = (y | y << 1) & 0x55;
    unsigned short z = x | y << 1;
    cout << z << endl;
    return 0;
}

假设输入的x、y均是不超过15的自然数，完成下面的判断题和单选题：

删去第7行与第13行的unsigned，程序行为不变。（）{{ select(16) }}

A. 正确
B. 错误

将第7行与第13行的short均改为char，程序行为不变。（）{{ select(17) }}

A. 正确
B. 错误

程序总是输出一个整数“0”。（）{{ select(18) }}

A. 正确
B. 错误

当输入为“2 2”时，输出为“10”。（）{{ select(19) }}

A. 正确
B. 错误

当输入为“2 2”时，输出为“59”。（）{{ select(20) }}

A. 正确
B. 错误

当输入为“13 8”时，输出为（）。{{ select(21) }}

A. “0”
B. “209”
C. “197”
D. “226”

(2)

#include <algorithm>
#include <iostream>
#include <limits>
using namespace std;

const int MAXN = 105;
const int MAXK = 105;

int h[MAXN][MAXK];

int f(int n, int m)
{
    if (m == 1) return n;
    if (n == 0) return 0;
    int ret = numeric_limits<int>::max();
    for (int i = 1; i <= n; i++)
        ret = min(ret, max(f(n - i, m), f(i - 1, m - 1)) + 1);
    return ret;
}

int g(int n, int m)
{
    for (int i = 1; i <= n; i++)
        h[i][1] = i;
    for (int j = 1; j <= m; j++)
        h[0][j] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 2; j <= m; j++) {
            h[i][j] = numeric_limits<int>::max();
            for (int k = 1; k <= i; k++)
                h[i][j] = min(
                    h[i][j],
                    max(h[i - k][j], h[k - 1][j - 1]) + 1);
        }
    }
    return h[n][m];
}

int main()
{
    int n, m;
    cin >> n >> m;
    cout << f(n, m) << endl << g(n, m) << endl;
    return 0;
}

假设输入的n、m均是不超过100的正整数，完成下面的判断题和单选题：

当输入为“7 3”时，第19行用来取最小值的min函数执行了449次。（）{{ select(22) }}

A. 正确
B. 错误

输出的两行整数总是相同的。（）{{ select(23) }}

A. 正确
B. 错误

当m为1时，输出的第一行总为n。（）{{ select(24) }}

A. 正确
B. 错误

算法g(n,m)最为准确的时间复杂度分析结果为（）。{{ select(25) }}

A. 𝑂(𝑛^3/2𝑚)
B. 𝑂(𝑛𝑚)
C. 𝑂(𝑛²𝑚)
D. 𝑂(𝑛𝑚²)

当输入为“20 2”时，输出的第一行为（）。{{ select(26) }}

A. “4”
B. “5”
C. “6”
D. “20”

（4分）当输入为“100 100”时，输出的第一行为（）。{{ select(27) }}

A. “6”
B. “7”
C. “8”
D. “9”

(3)

#include <iostream>
using namespace std;

int n, k;

int solve1()
{
    int l = 0, r = n;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (mid * mid <= n) l = mid + 1;
        else r = mid - 1;
    }
    return l - 1;
}

double solve2(double x)
{
    if (x == 0) return x;
    for (int i = 0; i < k; i++)
        x = (x + n / x) / 2;
    return x;
}

int main()
{
    cin >> n >> k;
    double ans = solve2(solve1());
    cout << ans << ' ' << (ans * ans == n) << endl;
    return 0;
}

假设int为32位有符号整数类型，输入的n是不超过47000的自然数、k是不超过int表示范围的自然数，完成下面的判断题和单选题：

该算法最准确的时间复杂度分析结果为𝑂(log𝑛+𝑘)。（）{{ select(28) }}

A. 正确
B. 错误

当输入为“9801 1”时，输出的第一个数为“99”。（）{{ select(29) }}

A. 正确
B. 错误

对于任意输入的n，随着所输入k的增大，输出的第二个数会变成“1”。（）{{ select(30) }}

A. 正确
B. 错误

该程序有存在缺陷。当输入的n过大时，第12行的乘法有可能溢出，因此应当将mid强制转换为64位整数再计算。（）{{ select(31) }}

A. 正确
B. 错误

当输入为“2 1”时，输出的第一个数最接近（）。{{ select(32) }}

A. 1
B. 1.414
C. 1.5
D. 2

当输入为“3 10”时，输出的第一个数最接近（）。{{ select(33) }}

A. 1.7
B. 1.732
C. 1.75
D. 2

当输入为“256 11”时，输出的第一个数（）。{{ select(34) }}

A. 等于16
B. 接近但小于16
C. 接近但大于16
D. 前三种情况都有可能

三、完善程序

（1）（枚举因数）从小到大打印正整数n的所有正因数。试补全枚举程序。

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n;
    cin >> n;

    vector<int> fac;
    fac.reserve((int)ceil(sqrt(n)));

    int i;
    for (i = 1; i * i < n; ++i) {
        if (①) {
            fac.push_back(i);
        }
    }

    for (int k = 0; k < fac.size(); ++k) {
        cout << ② << " ";
    }
    if (③) {
        cout << ④ << " ";
    }
    for (int k = fac.size() - 1; k >= 0; --k) {
        cout << ⑤ << " ";
    }
}

①处应填（）{{ select(35) }}

A. n % i == 0
B. n % i == 1
C. n % (i-1) == 0
D. n % (i-1) == 1

②处应填（）{{ select(36) }}

A. n / fac[k]
B. fac[k]
C. fac[k]-1
D. n / (fac[k]-1)

③处应填（）{{ select(37) }}

A. (i-1) * (i-1) == n
B. (i-1) * i == n
C. i * i == n
D. i * (i-1) == n

④处应填（）{{ select(38) }}

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

⑤处应填（）{{ select(39) }}

A. n / fac[k]
B. fac[k]
C. fac[k]-1
D. n / (fac[k]-1)

（2）（洪水填充）现有用字符标记像素颜色的8x8图像。颜色填充的操作描述如下：给定起始像素的位置和待填充的颜色，将起始像素和所有可达的像素（可达的定义：经过一次或多次的向上、下、左、右四个方向移动所能到达且终点和路径上所有像素的颜色都与起始像素颜色相同），替换为给定的颜色。试补全程序。

#include <bits/stdc++.h>
using namespace std;

const int ROWS = 8;
const int COLS = 8;

struct Point {
    int r, c;
    Point(int r, int c) : r(r), c(c) {}
};

bool is_valid(char image[ROWS][COLS], Point pt,
                int prev_color, int new_color) {
    int r = pt.r;
    int c = pt.c;
    return (0 <= r && r < ROWS && 0 <= c && c < COLS &&
            ① && image[r][c] != new_color);
}

void flood_fill(char image[ROWS][COLS], Point cur, int new_color) {
    queue<Point> queue;
    queue.push(cur);
    ②;
    int prev_color = image[cur.r][cur.c];

    while (!queue.empty()) {
        Point pt = queue.front();
        queue.pop();

        Point points[4] = {③, Point(pt.r - 1, pt.c),
                            Point(pt.r, pt.c + 1), Point(pt.r, pt.c - 1)};
        for (auto p : points) {
            ④;
            if (is_valid(image, p, prev_color, new_color)) {
                ⑤;
            }
        }
    }
}

int main() {
    char image[ROWS][COLS] = {{'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g'},
                               {'g', 'g', 'g', 'g', 'g', 'g', 'r', 'r'},
                               {'g', 'r', 'r', 'g', 'g', 'r', 'g', 'g'},
                               {'g', 'b', 'b', 'b', 'b', 'r', 'g', 'r'},
                               {'g', 'g', 'g', 'b', 'b', 'r', 'g', 'r'},
                               {'g', 'g', 'g', 'b', 'b', 'b', 'b', 'r'},
                               {'g', 'g', 'g', 'g', 'g', 'b', 'g', 'g'},
                               {'g', 'g', 'g', 'g', 'g', 'b', 'b', 'g'}};

    Point cur(4, 4);
    char new_color = 'y';

    flood_fill(image, cur, new_color);

    for (int r = 0; r < ROWS; r++) {
        for (int c = 0; c < COLS; c++) {
            cout << image[r][c] << " ";
        }
        cout << endl;
    }
    // 输出：
    // g g g g g g g g
    // g g g g g g r r
    // g r r g g r g g
    // g y y y y r g r
    // g g g y y r g r
    // g g g y y y y r
    // g g g g g y g g
    // g g g g g y y g
    return 0;
}

①处应填（）{{ select(40) }}

A. image[r][c] == prev_color
B. image[r][c] != prev_color
C. image[r][c] == new_color
D. image[r][c] != new_color

②处应填（）{{ select(41) }}

A. image[cur.r+1][cur.c] = new_color
B. image[cur.r][cur.c] = new_color
C. image[cur.r][cur.c+1] = new_color
D. image[cur.r][cur.c] = prev_color

③处应填（）{{ select(42) }}

A. Point(pt.r, pt.c)
B. Point(pt.r, pt.c+1)
C. Point(pt.r+1, pt.c)
D. Point(pt.r+1, pt.c+1)

④处应填（）{{ select(43) }}

A. prev_color = image[p.r][p.c]
B. new_color = image[p.r][p.c]
C. image[p.r][p.c] = prev_color
D. image[p.r][p.c] = new_color

⑤处应填（）{{ select(44) }}

A. queue.push(p)
B. queue.push(pt)
C. queue.push(cur)
D. queue.push(Point(ROWS,COLS))

#CSPJ2022CS. cspj组2022年初赛

Status

Development

Support

About