2022年CSP-J入门级第一轮初赛真题

已于 2024-05-25 16:18:26 修改
阅读量767 收藏 18
点赞数 29
分类专栏： # CSP-J初赛真题+解析 文章标签： c++ CSP - J
于 2024-05-25 16:17:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46192147/article/details/139197077
版权

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

第 1 题 以下哪种功能没有涉及C++语言的面向对象特性支持：（ ）。
A. C++中调用printf函数
B. C++中调用用户定义的类成员函数
C. C++中构造一个class或struct
D. C++中构造来源于同一基类的多个派生类

第 2 题 有6个元素，按照6、5、4、3、2、1的顺序进入栈S，请问下列哪个出栈序列是非法的（ ）。
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

第 3 题 运行以下代码片段的行为是（ ）。
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的地址

第 4 题 链表和数组的区别包括（ ）。
A. 数组不能排序，链表可以
B. 链表比数组能存储更多的信息
C. 数组大小固定，链表大小可动态调整
D. 以上均正确

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

第 6 题 对表达式a+(b-c)*d的前缀表达式为（ ），其中+、-、是运算符。
A. +a-bcd
B. +a-bcd
C. abc-d+
D. abc-+d

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

第 8 题 一棵有n个结点的完全二叉树用数组进行存储与表示，已知根结点存储在数组的第1个位置。若存储在数组第9个位置的结点存在兄弟结点和两个子结点，则它的兄弟结点和右子结点的位置分别是（ ）。
A. 8、18
B. 10、18
C. 8、19
D. 10、19

第 9 题 考虑由N个顶点构成的有向连通图，采用邻接矩阵的数据结构表示时，该矩阵中至少存在（ ）个非零元素。
A. N-1
B. N
C. N+1
D. N^2

第 10 题 以下对数据结构的表述不恰当的一项为：（ ）。
A. 图的深度优先遍历算法常使用的数据结构为栈。
B. 栈的访问原则为后进先出，队列的访问原则是先进先出。
C. 队列常常被用于广度优先搜索算法。
D. 栈与队列存在本质不同，无法用栈实现队列。

第 11 题 以下哪组操作能完成在双向循环链表结点p之后插入结点s的效果（其中，next域为结点的直接后继，prev域为结点的直接前驱）：（ ）。
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;

第 12 题 以下排序算法的常见实现中，哪个选项的说法是错误的：（ ）。
A. 冒泡排序算法是稳定的
B. 简单选择排序是稳定的
C. 简单插入排序是稳定的
D. 归并排序算法是稳定的

第 13 题 八进制数32.1对应的十进制数是（ ）。
A. 24.125
B. 24.250
C. 26.125
D. 26.250

第 14 题 一个字符串中任意个连续的字符组成的子序列称为该字符串的子串，则字符串abcab有（ ）个内容互不相同的子串。
A. 12
B. 13
C. 14
D. 15

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

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

（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的自然数，完成下面的判断题和单选题。

判断题

第 16 题 删去第7行与第13行的unsigned，程序行为不变。（ ）

第 17 题 将第7行与第13行的short均改为char，程序行为不变。（ ）

第 18 题 程序总是输出一个整数“0”。（ ）

第 19 题 当输入为“2 2”时，输出为“10”。（ ）

第 20 题 当输入为“2 2”时，输出为“59”。（ ）

单选题

第 21 题 当输入为“13 8”时，输出为（ ）。

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

判断题

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

第 23 题 输出的两行整数总是相同的。（ ）

第 24 题 当m为1时，输出的第一行总为n。（ ）

单选题

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

  • 在这里插入图片描述

第 26 题 当输入为“20 2”时，输出的第一行为（ ）。

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

第 27 题 当输入为“100 100”时，输出的第一行为（ ）。

  • 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表示范围的自然数，完成下面的判断题和单选题。

判断题

第 28 题 该算法最准确的时间复杂度分析结果为O(log n + k)。（ ）

第 29 题 当输入为“9801 1”时，输出的第一个数为“99”。（ ）

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

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

单选题

第 32 题 当输入为“2 1”时，输出的第一个数最接近（ ）。

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

第 33 题 当输入为“3 10”时，输出的第一个数最接近（ ）。

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

第 34 题 当输入为“256 11”时，输出的第一个数（ ）。

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

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

（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 << ⑤ << " ";
    }
}
选择题

第 35 题 ①处应填（ ）

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

第 36 题 ②处应填（ ）

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

第 37 题 ③处应填（ ）

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

第 38 题 ④处应填（ ）

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

第 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; 
 }
选择题

第 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

第 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

第 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)

第 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

第 44 题 ⑤处应填（ ）

  • A. queue.push§
  • B. queue.push(pt)
  • C. queue.push(cur)
  • D. queue.push(Point(ROWS,COLS))
天秀信奥编程培训
关注
  • 29
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
历年CSP-J初赛真题解析 | 2023年CSP-J初赛完善程序（33-42）
COCO_gsta的博客
09-27 641
可以代入nums = [1,2,3,5,6]进行验算，第一次while循环，mid = 2，nums[2] == 3，满足nums[mid] == mid + num[0]（3 == 2 + 1）。同39题，dp[m][n]表示长度为m的字符串变成长度为n的字符串最少步数，那么dp[i][0]就应该表示str1长度为i的字符串变成长度为0的字符串最少步数。dp[m][n]表示长度为m的字符串变成长度为n的字符串最少步数，那么dp[0][j]就应该表示str1长度为0的字符串变成长度为j的字符串最少步数。
2019年CSP-J入门级第一轮初赛真题解析
m0_46192147的博客
05-03 629
国家顶级域名（Country Code Top-Level Domain，ccTLD）是指由国际标准化组织 ISO 在 ISO 3166-1 中指定的用于区别不同国家和地区的两位字母的代码。这个过程体现了二叉树的递归性质:每个子树都可以看作一棵独立的二叉树,具有相同的结构和性质。中国的国家顶级域名是 .cn，它是中国在互联网上的一个标识符。好的,让我们用图形来详细展示如何根据后序遍历序列和中序遍历序列推导出前序遍历序列。因此,左子树的前序遍历序列是:B -> D -> GEHJ,即 BDGEHJ。
CSP-J 2022 入门级 第一轮 阅读程序(1) 第16-21题
君义NOIP的博客
09-21 5544
（例如对机器数10000000左移1位操作，如果是16位机器数，结果为100000000，如果是八位机器数，结果为00000000）。看一下后面几题，也能看出不可能对于什么输入，输出的都是0，否则后面三题都当做结果是0好了。看x的后4位，x为0010，x
2023CSP-J 组真题 1. apple（苹果）
weixin_40252159的博客
03-18 397
由于编号为n的永远是在最后一个，所以当第一次剩余数量 m为3倍余1时，最后一个会被取走，记录此时的天数即可。所以第一个问题：几天取完可以根据每天剩余 m-(m+2)/3，while循环直至m变为0。由于从编号 1开始，每隔 2个取走1个，所以实际是每3个取走1个...假设每一轮开始前的总数为 m，因为每一组取走的都是第1个，所以根据。第二轮取走 (5+2)/3=2个，剩余3个，第三轮取走 (3+2)/3=1个，剩余2个，第四轮取走 (2+2)/3=1个，剩余1个；第一轮取走 10/3=3个，剩余5个；
CSP-J 2023真题解析
风中的微尘的博客
11-04 1135
做模拟题最关键的问题是，很多时候你不知道它在说什么，你大概率美学过，没看过。但这不重要，你只需要读完全部题目即可，它一定会给足所有信息，只需。问最早到终点的时刻是多少，如果不存在这样的方案，输出。，要求不能早于这个时刻通过此点，且不允许在同种任何地方停留。但是模拟题的问题在于，你很难拿到满分，你有一下问题需要注意。的整数来判断是否有解，以及求最大的解，这样可以得到。现要从起点一直走到终点，要求到达终点的时刻一定是。现求多少天能拿完所有的苹果，而编号为。如题所示，一个字都别漏，纯纯的模拟题。
2023年CSP-J认证 CCF信息学奥赛C++ 中小学初级组 第一轮真题-完善程序题解析
青少年编程学习指导
03-09 2076
2023CCF认证第一轮（CSP-J）真题 三、完善程序题 第一题寻找被移除的元素 问题：原有长度为 n+1公差为1等升数列，将数列输到程序的数组时移除了一个元素，导致长度为 n 的开序数组可能不再连续，除非被移除的是第一个或最后之个元素。需要在数组不连续时，找出被移除的元素。试补全程序。
2023年CSP-J真题详解+分析数据（选择题篇）
m0_73787047的博客
10-06 1476
2023年CSP-J选择题部分讲解
2020 CSP-J 入门级 初赛 第一轮 试题与解析 PDF.rar
09-08
2020 CSP-J 入门级 初赛 第一轮 试题与解析 PDF.rar
NOIP CSP-J CSP-S 初赛 第1轮 学习资料集（C）-2023.06.12.pdf
06-12
NOIP CSP-J CSP-S 初赛 第1轮 学习资料集（C）--2023.06.12
2019 2020 CSP-J CSP-S组 第1轮 初赛 答案+解析.rar
09-04
2019 2020 CSP-J CSP-S组 第1轮 初赛 答案+解析.rar
2021 CSP-J1 junior-C++ 初赛　第1轮　真题　.pdf
09-20
CSP-J1 初赛真题解析 本文档是对 2021 CSP-J1 junior-C++ 初赛第 1 轮真题的详细解析，以帮助读者更好地理解题目内容和解题思路。 一、单项选择题 1. 不属于面向对象程序设计语言的是（ ）。 答案：D. C。面向...
CSP-J入门组 历年真题 第1题（部分）python版.zip
11-17
CSP-J入门组 历年真题 第1题（部分）python版.zip
2023年CCF非专业级别软件能力认证第二轮 （CSP-J）入门级C++语言试题
No0d1es的博客
11-09 468
小Z希望乘坐旅游巴士到达景区入口，并沿着自己选择的任意路径走到景区出口，再乘坐旅游巴士离开，这意味着他到达和离开景区的时间都必须是k的非负整数倍。输入的接下来m行，每行包含3个非负整数ui,vi,ai，表示第i条道路从地点ui出发，到达地点vi，道路的“开放时间”为ai。对于所有测试数据有：2≤n≤104，1≤m≤2×104，1≤k≤100，1≤ui,vi≤n，0≤ai≤106。公路上每个站点都可以加油，编号为i的站点一升油的价格为ai元，且每个站点只出售整数升的油。公路上一共有n个站点，编号为从1到n。
历年CSP-J初赛真题解析 | 2023年CSP-J初赛阅读程序（16-32）
COCO_gsta的博客
09-17 987
17、将第7行中的“(s - b) * (s - c)”改“(s - c) * (s - b)”不会影响程序运行的结果。学习C++从娃娃抓起！将"3 4 5"带入计算，其实就是求直角三角形的面积，得到6.0000，选A。当a、b、c无法构成面积时，计算结果为0.0000，也仍然保留四位小数。16、当输入为“2 2 2”时，输出为“1.7321"。同19题，也是求直角三角形的面积，得30.0000，选B。20、当输入为“5 12 13”时，输出为（ ）。19、当输入为“3 4 5”时，输出为（ ）
[最全]2023年CSP-J组初赛真题及答案
m0_52563006的博客
09-17 787
[最全]2023年CSP-J组初赛真题及答案
CSP-J 2022 第一轮试题 答案解析
热门推荐
君义NOIP的博客
09-21 1万+
已知入栈顺序是：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，双亲的下。
【2023csp-J】CSP-J初赛总结与回顾
我发布的博客，快来抄答案吧
09-24 206
csp2023总结回顾与经验分享
【C++】——Stack与Queue（含优先队列（详细解读）
最新发布
m0_74092462的博客
06-09 1032
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 154
BCSP-X 11题 C++代码详解
2020csp-j入门级第一轮试题及参考答案.pdf
09-10
《2020csp-j入门级第一轮试题及参考答案.pdf》是一份题目和答案的文档，是针对2020年的csp-j入门级考试的第一轮试题的。csp-j是一个计算机科学与技术竞赛，对于初学者来说是入门级别的考试。 这份文档包含了考试中的试题以及每道题目的参考答案。通过学习和解答这些试题，考生可以对计算机科学与技术的基础知识和编程技巧进行巩固和提高。 文档中的题目可能涉及到各个方面的计算机知识，比如算法、数据结构、编程语言等。考生需要通过理解题目要求，设计和实现相应的算法和程序来解决问题，并根据参考答案对自己的解答进行对比和矫正。 此文档的目的是让考生熟悉考试题型和要求，提高解决问题的能力和技巧，并为考生提供一个参考和学习的资源。考生可以根据试题和答案中的解析和讲解，加深对计算机科学与技术的理解和掌握。 总之，《2020csp-j入门级第一轮试题及参考答案.pdf》是一份有助于考生提升计算机科学与技术水平的学习材料，通过学习和实践，考生可以更好地备战csp-j入门级考试。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天秀信奥编程培训

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值