CSP 2022 入门级第一轮

最新推荐文章于 2024-08-30 09:21:39 发布
最新推荐文章于 2024-08-30 09:21:39 发布
阅读量588 收藏 6
点赞数 14
文章标签： 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjl_8616/article/details/141336182
版权

第 1 题

一、单项选择题（共 15 题，每题 2 分，共计 30 分；每题有且仅有一个正确选项）

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

  1.  A. 

    C++ 中调用 printf 函数

     B. 

    C++ 中调用用户定义的类成员函数

     C. 

    C++ 中构造一个 class 或 struct

     D. 

    C++ 中构造来源于同一基类的多个派生类

    正确答案： A


得分: 2 / 2 分

第 2 题

有 66 个元素，按照 6,5,4,3,2,16,5,4,3,2,1 的顺序进入栈 SS，请问下列哪个出栈序列是非法的（ ）。

  1.  A. 

    5,4,3,6,1,25,4,3,6,1,2

     B. 

    4,5,3,1,2,64,5,3,1,2,6

     C. 

    3,4,6,5,2,13,4,6,5,2,1

     D. 

    2,3,4,1,5,62,3,4,1,5,6

    正确答案： C


得分: 2 / 2 分

第 3 题

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

int x = 101;
int y = 201;
int *p = &x;
int *q = &y;
p = q;
  1.  A. 

    将 xx 的值赋为 201201

     B. 

    将 yy 的值赋为 101101

     C. 

    将 qq 指向 xx 的地址

     D. 

    将 pp 指向 yy 的地址

    正确答案： D


得分: 2 / 2 分

第 4 题

链表和数组的区别包括（ ）。

  1.  A. 

    数组不能排序，链表可以

     B. 

    链表比数组能存储更多的信息

     C. 

    数组大小固定，链表大小可动态调整

     D. 

    以上均正确

    正确答案： C


得分: 2 / 2 分

第 5 题

对假设栈 SS 和队列 QQ 的初始状态为空。存在 e1∼e6e1​∼e6​ 六个互不相同的数据，每个数据按照进栈 SS、出栈 SS、进队列 QQ、出队列 QQ 的顺序操作，不同数据间的操作可能会交错。已知栈 SS 中依次有数据 e1e1​、e2e2​、e3e3​、e4e4​、e5e5​ 和 e6e6​ 进栈，队列 QQ 依次有数据 e2e2​、e4e4​、e3e3​、e6e6​、e5e5​ 和 e1e1​ 出队列。则栈 SS 的容量至少是（ ）个数据。

  1.  A. 

    22

     B. 

    33

     C. 

    44

     D. 

    66

    正确答案： B


得分: 2 / 2 分

第 6 题

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

  1.  A. 

    *+a-bcd

     B. 

    +a*-bcd

     C. 

    abc-d*+

     D. 

    abc-+d

    正确答案： B


得分: 2 / 2 分

第 7 题

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

  1.  A. 

    11

     B. 

    22

     C. 

    22 或 33

     D. 

    33

    正确答案： B


得分: 2 / 2 分

第 8 题

一棵有 nn 个结点的完全二叉树用数组进行存储与表示，已知根结点存储在数组的第 11 个位置。若存储在数组第 99 个位置的结点存在兄弟结点和两个子结点，则它的兄弟结点和右子结点的位置分别是（ ）。

  1.  A. 

    88、1818

     B. 

    1010、1818

     C. 

    88、1919

     D. 

    1010、1919

    正确答案： C


得分: 2 / 2 分

第 9 题

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

  1.  A. 

    N−1N−1

     B. 

    NN

     C. 

    N+1N+1

     D. 

    N2N2

    正确答案： B


得分: 0 / 2 分

第 10 题

以下对数据结构的表述不恰当的一项为：（ ）。

  1.  A. 

    图的深度优先遍历算法常使用的数据结构为栈。

     B. 

    栈的访问原则后进先出，队列的访问原则是先进先出。

     C. 

    队列常常被用于广度优先搜索算法。

     D. 

    栈与队列存在本质不同，无法用栈实现队列。

    正确答案： D


得分: 2 / 2 分

第 11 题

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

  1.  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;

    正确答案： D


得分: 2 / 2 分

第 12 题

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

  1.  A. 

    冒泡排序算法是稳定的

     B. 

    简单选择排序是稳定的

     C. 

    简单插入排序是稳定的

     D. 

    归并排序算法是稳定的

    正确答案： B


得分: 2 / 2 分

第 13 题

八进制数 32.132.1 对应的十进制数是（ ）。

  1.  A. 

    24.12524.125

     B. 

    24.25024.250

     C. 

    26.12526.125

     D. 

    26.25026.250

    正确答案： C


得分: 2 / 2 分

第 14 题

一个字符串中任意个连续的字符组成的子序列称为该字符串的子串，则字符串 abcababcab 有（ ）个内容互不相同的子串。

  1.  A. 

    1212

     B. 

    1313

     C. 

    1414

     D. 

    1515

    正确答案： B


得分: 2 / 2 分

第 15 题

以下对递归方法的描述中，正确的是：（ ）。

  1.  A. 

    递归是允许使用多组参数调用函数的编程技术

     B. 

    递归是通过调用自身来求解问题的编程技术

     C. 

    递归是面向对象和数据而不是功能和逻辑的编程语言模型

     D. 

    递归是将用某种高级语言转换为机器代码的编程技术

    正确答案： B


得分: 2 / 2 分

第 16 题

二、阅读程序（程序输入不超过数组或字符串定义的范围；判断题正确填 √，错误填 ⨉ ；除特殊说明外，判断题 1.5 分，选择题 3 分，共计 40 分）

(1)

01 #include <iostream>
02
03 using namespace std；
04
05 int main()
06 {
07     unsigned short x, y；
08     cin >> x >> y；
09     x = (x | x << 2)& 0x33；
10     x = (x | x << 1)& 0x55；
11     y = (y | y << 2)& 0x33；
12     y = (y | y << 1)& 0x55；
13     unsigned short z = x | y << 1；
14     cout << z << endl；
15     return 0；
16 }

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

判断题

  1. 删去第 77 行与第 1313 行的 unsigned，程序行为不变。
  2. 将第 77 行与第 1313 行的 short 均改为 char，程序行为不变。
  3. 程序总是输出一个整数“0”。
  4. 当输入为 2 2 时，输出为 10。
  5. 当输入为 2 2 时，输出为 59。

单选题

  1. 当输入为 13 8 时，输出为（ ）。
  1. 1. A. 

    正确

     B. 

    错误

    正确答案： A

  2. 2. A. 

    正确

     B. 

    错误

    正确答案： B

  3. 3. A. 

    正确

     B. 

    错误

    正确答案： B

  4. 4. A. 

    正确

     B. 

    错误

    正确答案： B

  5. 5. A. 

    正确

     B. 

    错误

    正确答案： B

  6. 6. A. 

    00

     B. 

    209209

     C. 

    197197

     D. 

    226226

    正确答案： B


得分: 7.5 / 10.5 分

第 17 题

（2）

1  #include <algorithm>
2  #include <iostream>
3  #include <limits>
4  
5  using namespace std;
6  
7  const int MAXN = 105;
8  const int MAXK = 105;
9  
10 int h[MAXN][MAXK];
11 
12 int f(int n, int m)
13 {
14     if (m == 1) return n;
15     if (n == 0) return 0;
16 
17     int ret = numeric_limits<int>::max();
18     for (int i = 1; i <= n; i++)
19         ret = min(ret, max(f(n - i,m), f(i - 1, m - 1)) + 1);
20     return ret;
21 }
22 
23 int g(int n, int m)
24 {
25     for (int i = 1;i <= n; i++)
26         h[i][1]= i;
27     for (int j = 1;j<= m; j++)
28         h[0][j]= 0;
29 
30     for (int i= 1; i <= n; i++){
31         for (int j= 2; j <= m; j++){
32             h[i][j] = numeric_limits<int>::max();
33             for (int k = 1;k <= i;k++)
34             h[i][j]= min(
35                 h[i][j],
36                 max(h[i - k][j],h[k - 1][j - 1]) +1);
37         }
38     }
39 
40     return h[n][m];
41 }
42 
43 int main()
44 {
45     int n,m;
46     cin >> n>> m;
47     cout << f(n, m) << endl << g(n, m)<< endl;
48     return 0;
49 }

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

判断题

  1. 当输入为 7 3 时，第 1919 行用来取最小值的 min 函数执行了 449449 次。
  2. 输出的两行整数总是相同的。
  3. 当 mm 为 11 时，输出的第一行总为 nn。

单选题

  1. 算法 g(n,m)g(n,m) 最为准确的时间复杂度分析结果为（ ）。
  2. 当输入为 20 2 时，输出的第一行为（ ）。
  3. （44 分） 当输入 100 100 时，输出的第一行为（ ）。
  1. 1. A. 

    正确

     B. 

    错误

    正确答案： B

  2. 2. A. 

    正确

     B. 

    错误

    正确答案： A

  3. 3. A. 

    正确

     B. 

    错误

    正确答案： A

  4. 4. A. 

    O(n3/2m)O(n3/2m)

     B. 

    O(nm)O(nm)

     C. 

    O(n2m)O(n2m)

     D. 

    O(nm2)O(nm2)

    正确答案： C

  5. 5. A. 

    44

     B. 

    55

     C. 

    66

     D. 

    2020

    正确答案： C

  6. 6. A. 

    66

     B. 

    77

     C. 

    88

     D. 

    99

    正确答案： B


得分: 10.5 / 14.5 分

第 18 题

(3)

1  #include <iostream>
2  
3  using namespace std;
4  
5  int n,k;
6  
7  int solve1()
8  {
9      int l = 0, r = n;
10     while(l <= r){
11         int mid = (l + r) / 2;
12         if (mid * mid <= n) l = mid + 1;
13         else r = mid - 1;
14     }
15     return l - 1;
16 }
17 
18 double solve2(double x)
19 {
20         if (x == 0) return x;
21         for (int i = 0; i < k; i++)
22             x = (x + n / x) / 2;
23     return x;
24 }
25 
26 int main()
27 {
28     cin >> n >> k;
29     double ans = solve2(solve1());
30     cout << ans << ' ' << (ans * ans == n) << endl;
31     return 0;
32 }

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

判断题

  1. 该算法最准确的时间复杂度分析结果为 O(log⁡n+k)O(logn+k)。
  2. 当输入为 9801 1 时，输出的第一个数为 99。
  3. 对于任意输入的 nn，随着所输入 kk 的增大，输出的第二个数会变成 11。
  4. 该程序有存在缺陷。当输入的 nn 过大时，第 1212 行的乘法有可能溢出，因此应当将 mid 强制转换为 6464 位整数再计算。

单选题

  1. 当输入为 2 1 时，输出的第一个数最接近（ ）。
  2. 当输入为 3 10 时，输出的第一个数最接近（ ）。
  3. 当输入为 256 11 时，输出的第一个数（ ）。
  1. 1. A. 

    正确

     B. 

    错误

    正确答案： A

  2. 2. A. 

    正确

     B. 

    错误

    正确答案： A

  3. 3. A. 

    正确

     B. 

    错误

    正确答案： B

  4. 4. A. 

    正确

     B. 

    错误

    正确答案： B

  5. 5. A. 

    11

     B. 

    1.4141.414

     C. 

    1.51.5

     D. 

    22

    正确答案： C

  6. 6. A. 

    1.71.7

     B. 

    1.7321.732

     C. 

    1.751.75

     D. 

    22

    正确答案： B

  7. 7. A. 

    等于 1616

     B. 

    接近但小于 1616

     C. 

    接近但大于 1616

     D. 

    前三种情况都有可能

    正确答案： A


得分: 12 / 15 分

第 19 题

三、完善程序（单选题，每小题 33 分，共计 3030 分）

（1）（枚举因数）从小到大打印正整数 nn 的所有正因数。

试补全枚举程序。

#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 << ⑤ << "";
    }
}

①~⑤处应填（ ）

  1. 1. A. 

    n % i == 0

     B. 

    n % i == 1

     C. 

    n % (i-1) == 0

     D. 

    n % (i-1) == 1

    正确答案： A

  2. 2. A. 

    n / fac[k]

     B. 

    fac[k]

     C. 

    fac[k]-1

     D. 

    n / (fac[k]-1)

    正确答案： B

  3. 3. A. 

    (i-1)*(i-1)== n

     B. 

    (i-1)*i == n

     C. 

    i*i == n

     D. 

    i*(i-1) == n

    正确答案： C

  4. 4. A. 

    n-i

     B. 

    n-i+1

     C. 

    i-1

     D. 

    i

    正确答案： D

  5. 5. A. 

    n / fac[k]

     B. 

    fac[k]

     C. 

    fac[k]-1

     D. 

    n / (fac[k]-1)

    正确答案： A


得分: 12 / 15 分

第 20 题

（2）（洪水填充）

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

试补全程序。

#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;
}

①~⑤处应填（ ）

  1. 1. A. 

    image[r][c] == prev_color

     B. 

    `image[r][c] != prev_color

     C. 

    image[r][c] == new_color

     D. 

    image[r][c] != new_color

    正确答案： A

  2. 2. 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

    正确答案： B

  3. 3. 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)

    正确答案： C

  4. 4. 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

    正确答案： D

  5. 5. A. 

    queue.push(p)

     B. 

    queue. push (pt)

     C. 

    queue.push(cur)

     D. 

    queue. push(Point (ROWS, COLS))

    正确答案： A


得分: 9 / 15 分

吃菠萝的狼
关注
2022 CSP-J1 CSP-S1 初赛 第1轮 真题讲评 真题解析
青少年趣味编程
09-21 4756
2022 CSP-J1 CSP-S1 初赛 第1轮 真题讲评 真题解析
2022年CCF-CSP真题及答案解析
LCY20110310的博客
06-04 2709
为按位或运算，& 为按位与运算，<< 为左移运算。依题意模拟过程，括号中表示栈中数据的个数：e1入栈(1)，e2入栈(2)，e2出栈(1)，e3入栈(2)，e4入栈(3)，e4出栈(2)，e3出栈(1)，e5入栈(2)，e6入栈(3)，e6出栈(2)，e5出栈(1)，e1出栈(0)。【解析】代入模拟，先计算出m=1，m=2，m=3的情况，找出规律，可以发现当m = 100的时候，列举出n从1~100的结果，为1个1，2个2，4个3，8个4，16个5，32个6，37个7，因此结果为7。
CSP-J 2022 入门级 第一轮 阅读程序（2） 第22-27题
君义NOIP的博客
09-23 7409
设想j=4时，i从0到7，h[i][4]的值与h[i][3]的值都相同，那么从h[8][4]开始，随着i的增大，需要填一些4，那么什么时候应该填5呢，需要让每个数对的最大值都是4，前面h[0][3]到h[7][3]是0,1,2,2,3,3,3,3，共8个数字，需要与后面8个数字4配对，这8个数字的位置应该为h[15][4]到h[8][4]，这样最大值都是4，接下来h[8][3]往下都是4，与j=4的一列较小值配对，最大值都是4。j是2时确定了有2个2，j是3时确定了有4个3，j是4时就能确定有8个4，…
CSP-J 2022 入门级 第一轮 阅读程序（3） 第28-34题
君义NOIP的博客
09-23 4672
所以在solve2中x=(x+n/x)/2=(16+256/16)/2=16，每次计算后x的值不变，都是16。把1传入solve2，x为1，循环1次，x = (x+n/x)/2=(1+2/1)/2=1.5，函数的返回值，也就是ans的值为1.5。sove2中x=99，k为1，for循环执行一次，x=(x+n/x)/2=(99+9801/99)/2=99。把1传入solve2，x为1，循环10次，，每次循环让x=(x+n/x)/2，用模拟运行法。solve1函数是二分算法，二分查找的范围为n，复杂度为。
2022 CSP-J入门级第一轮试题
最新发布
legulas66的专栏
08-30 648
定起始像素的位置和待填充的颜色，将起始像素和所有可达的像素（可达的定义：经过 一次或多次的向上、下、左、右四个方向移动所能到达且终点和路径上所有像素的颜色。栈 S 中依次有数据 e1 、 e2 、 e3 、 e4 、 e5 和 e6 进栈，队列 Q 依次有数据 e2 、 e4 、 e3 、2. 有 6 个元素，按照 6 、 5 、 4 、 3 、 2 、 1 的顺序进入栈 S ，请问下列哪个出栈序列是非法的。进栈 S 、出栈 S 、进队列 Q 、出队列 Q 的顺序操作，不同数据间的操作可能会交错。
CSP 2020 入门组第一轮.pdf
09-08
CSP 2020 入门组第一轮 本资源提供了 CSP 2020 入门组第一轮考试的相关知识点，涵盖计算机科学和编程领域的多个方面。下面是根据给定的文件信息生成的相关知识点： 计算机存储器 1. 在内存储器中，每个存储单元都...
2020 CSP-J 入门级 初赛 第一轮 试题与解析 PDF.rar
09-08
《2020 CSP-J 入门级 初赛 第一轮 试题与解析》 CSP-J（入门级）是中国计算机学会（CCF）组织的计算机编程能力认证的一部分，主要面向初中生，旨在培养和评估学生的算法设计和编程能力。初赛作为第一轮比赛，是对...
CSP 2019 入门组初赛第一轮试题.pdf
09-18
CSP 2019 入门组初赛第一轮试题
2022 CSP-J1 CSP-S1 初赛 资料集（2022.07.08).pdf
07-08
本资源是关于 2022 年 CSP-J1 CSP-S1 初赛的资料集，包含了报名通知、成绩及分数线汇总、相关书籍、培训计划、学习要点、复习方法、知识汇总、模拟题、答案解析、视频等内容。本资源主要面向青少年趣味编程和 C++ ...
CSP-J1 2022 入门级第一轮错题
qiaohouze的博客
07-27 789
一棵有n个结点的完全二叉树用数组进行存储与表示，已知根结点存储在数组的第1个位置。若存储在数组第9个位置的结点存在兄弟结点和两个子结点，则它的兄弟结点和右子结点的位置分别是( )。假设字母表{a,b,c,d,e}在字符串出现的频率分别为10%,15%,30%,16%,29%。若使用哈夫曼编码方式对字母进行不定长的二进制编码，字母d的编码长度为(B)位。9为奇数，那么第9个位置的兄弟结点（同一个父结点）编号为8，它的右子结点编号为。解析： 使用数组存储完全二叉树，当结点编号为i时，其左右子结点的编号分别为。
CSP-J 2022 入门级 第一轮（初赛） 答案及解析
热门推荐
君义NOIP的博客
09-21 2万+
已知入栈顺序是：e1,e2,e3,e4,e5,e6，出栈顺序是：e2,e4,e3,e6,e5,e1，请问在整个入栈出栈过程中栈中元素的最大个数。中用到的都应该是变化前的p->next，指向的是原来p的下一个结点。printf是C语言中就可以使用的函数，而c++中定义类或结构体，对象调用成员函数，构造派生类，都是面向对象语言才能支持的操作。C选项中，当4出栈时，4前入栈的6,5一定都在栈中，情况为：栈底-6-5。二叉树的顺序存储结构中，第i结点的左孩子的下标为2*i，右孩子的下标为2*i+1，双亲的下。
2022 CSP-J1 入门组 初赛 第1轮 讲解 解析 真题讲解
青少年趣味编程
09-19 2423
2022 CSP-J1 初赛 第1轮 讲解 解析 真题讲解
2022CSP阅读程序真题附解析
lb201205的博客
07-09 2286
22年CSP答案加解析，作者包对的
CSP-J 2022年8月第一轮模拟赛 1
IT_Scratch的博客
09-06 1945
两个人抛硬币，规定第一个抛出正面的人可以吃到苹果，请问先抛的人能吃到苹果的概率多大。后总能有次序地选择敲击不同的地鼠，保证每次得到最大的总分值。时间可能是不同的，而且每个地鼠被敲击后增加的游戏分值也可能是不同，每个地鼠被敲击后，将会增加相应的游戏分值。后，某个地鼠冒出来后停留的时间都是固定的，而且他记录。F=错误，每空标号处均填选择的答案对应的大写字母)分，每空标号处均填选择的答案对应的大写字母)分，每空标号处均填选择的答案对应的大写字母)分，每空标号处均填选择的答案对应的大写字母)
2022年CSP-J入门级第一轮初赛真题
m0_46192147的博客
05-26 1071
第 5 题 若输入的 ( n ) 等于 205,891,132,094,649（即 30），输入的 ( k ) 为 33，则输出等于（ ）。第 6 题 若输入的 ( n ) 等于 100,010,002,000,090，输入的 ( k ) 为 10，则输出等于（ ）。第 6 题 （4 分）若输入的 ( n ) 为 15，接下来的输入是 15 到 1，以及 15 到 1，则输出为（ ）。第 4 题 若输入的 ( n ) 等于 10^(15)，输入的 ( k ) 为 1，则输出等于（ ）。
图的存储与遍历
IrisBrown的博客
05-08 1547
举个栗子 给出如下邻接矩阵： 画出从顶点1出发进行遍历所得的深度优先生成树和广度优先生成树。 ～1.概念 要画出对应深度优先生成树和广度优先生成树，就先要了解什么是深度优先遍历（DFS）什么是。关于什么是深度优先遍历，它的概念其实很容易搜到，我自己对它的方式的理解就是——“不撞南墙不回头”式遍历。 ...
CSP2020入门组第一轮试题与解析
"CSP2020入门组第一轮初赛试题答案及解析" 这篇资料涉及的是计算机科学与编程竞赛(CSP)入门组2020年第一轮的比赛内容。CSP，全称是中国计算机学会(CCF)组织的计算机程序设计能力认证，分为CSP-J（Junior）和CSP-S...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值