CSP-J 入门级第一轮认证 2025 详细解析

CSP-J 入门级第一轮认证 2025

一、选择题（每题2分，共30分）

1. 32位无符号整数可表示的最大值，最接近下列哪个选项？

• A. 4×10⁹
• B. 3×10¹⁰
• C. 2×10⁹
• D. 2×10¹⁰

答案：A

计算与分析过程：

• 32位无符号整数的取值范围是 0 ~ 2³² - 1（无符号数无符号位，所有位均表示数值）。
• 计算核心值：2³² = 4294967296，因此最大值为 4294967295（约42.9亿）。
• 选项对比：4×10⁹ = 40亿，与42.9亿最接近；B、D选项（30亿、20亿）量级不符，C选项（20亿）差距较大。

2. 在C++中，执行int x=255; cout<<(x & (x - 1));后，输出结果是？

• A. 255
• B. 254
• C. 128
• D. 0

答案：B

计算与分析过程：

1. 二进制转换：

   • x=255 的二进制为 0b11111111（8位有效位，32位整数高位补0，不影响位运算结果）。
   • x-1=254 的二进制为 0b11111110。

2. 位运算逻辑：

   • 位运算符 &（按位与）：对应位均为1时结果为1，否则为0。
   • 计算 0b11111111 & 0b11111110 = 0b11111110，对应十进制 254。
   • 补充：x & (x-1) 是清除整数最低位1的经典操作，常用于判断2的幂（若结果为0，则x是2的幂）。

3. 函数calc(n)定义如下，calc(5)的返回值是？

int calc(int n) {
   
   
    if(n<=1)return 1;          // 基线条件：n≤1时返回1
    if(n%2==0) return calc(n/2)+1;  // 偶数：递归n/2，计数+1
    else return calc(n-1) + calc(n-2); // 奇数：递归n-1和n-2，结果相加
}

• A. 5
• B. 6
• C. 7
• D. 8

答案：B

递归调用分析（展开调用栈）：

需从 calc(5) 逐步拆解至基线条件（n≤1）：

1. calc(5)：n是奇数（5%2=1）→ 调用 calc(4) + calc(3)
2. calc(4)：n是偶数（4%2=0）→ 调用 calc(2) + 1
   • calc(2)：n是偶数（2%2=0）→ 调用 calc(1) + 1
     • calc(1)：基线条件 → 返回1
   • 因此 calc(2) = 1 + 1 = 2，进而 calc(4) = 2 + 1 = 3
3. calc(3)：n是奇数（3%2=1）→ 调用 calc(2) + calc(1)
   • calc(2)=2，calc(1)=1 → 因此 calc(3) = 2 + 1 = 3
4. 最终 calc(5) = 3 + 3 = 6

4. 用5个权值10、12、15、20、25构造哈夫曼树，该树的带权路径长度是？

• A. 176
• B. 186
• C. 196
• D. 206

答案：B

哈夫曼树构造与带权路径长度计算：

哈夫曼树核心规则：每次选两个最小权值的节点合并，新节点权值为两者之和，重复至只剩一个节点；带权路径长度（WPL）= 所有叶子节点的「权值×根到叶子的边数」之和。

步骤1：构造哈夫曼树

1. 初始权值：[10, 12, 15, 20, 25]
2. 第1次合并：最小两个权值10和12 → 新节点22，剩余权值：[15, 20, 22, 25]
3. 第2次合并：最小两个权值15和20 → 新节点35，剩余权值：[22, 25, 35]
4. 第3次合并：最小两个权值22和25 → 新节点47，剩余权值：[35, 47]
5. 第4次合并：最后两个权值35和47 → 新节点82，树构造完成。

步骤2：计算WPL

• 叶子节点10、12：根到叶子的边数=3 → 贡献：10×3 + 12×3 = 66
• 叶子节点15、20：根到叶子的边数=2 → 贡献：15×2 + 20×2 = 70
• 叶子节点25：根到叶子的边数=2 → 贡献：25×2 = 50
• 总WPL：66 + 70 + 50 = 186

5. 在一个有向图中，所有顶点的入度之和等于所有顶点的出度之和，这个总和等于？

• A. 顶点数
• B. 边数
• C. 顶点数+边数
• D. 顶点数×2

答案：B

图论概念分析：

• 入度：顶点接收的边的数量；出度：顶点发出的边的数量。
• 核心逻辑：有向图中每条边对应一个“出度”（从起点出发）和一个“入度”（到终点），即一条边贡献1个出度和1个入度。
• 结论：所有顶点入度之和 = 所有顶点出度之和 = 边数。

6. 从5位男生和4位女生中选出4人组成学习小组，要求男女生都有。有多少种不同的选举方法？

• A. 126
• B. 121
• C. 120
• D. 100

答案：C

组合计数分析（间接法）：

“男女生都有”的反面是“全男生”或“全女生”，因此用「总选法 - 全男选法 - 全女选法」计算。

1. 组合数公式：C(n,k) = n!/(k!(n-k)!)（从n个中选k个的方案数）
2. 总选法：从9人中选4人 → C(9,4) = 9×8×7×6/(4×3×2×1) = 126
3. 全男选法：从5男生中选4人 → C(5,4) = 5
4. 全女选法：从4女生中选4人 → C(4,4) = 1
5. 符合条件的选法：126 - 5 - 1 = 120

7. 假设a、b、c都是布尔变量，逻辑表达式(a && b) || (!c && a)的值与下列哪个表达式不始终相等？

• A. a && (b || !c)
• B. (a || !c) && (b || !c) && (a || a)
• C. a && (!b || c)
• D. (!(!a || !b)) || (a && !c)

答案：C

布尔表达式等价性分析（化简+举例验证）：

步骤1：化简原表达式

原表达式：(a && b) || (a && !c) → 提取公因子a（分配律）→ a && (b || !c)，与选项A完全等价。

步骤2：验证选项C（反例法）

找一组a、b、c的值，使原表达式与选项C结果不同：

• 取 a=1（真）、b=1（真）、c=0（假）：
  • 原表达式：(1&&1) || (!0&&1) = 1 || 1 = 1
  • 选项C：1 && (!1 || 0) = 1 && (0 || 0) = 0
• 结果不同，因此选项C与原表达式不等价。

8. 已知f[0]=1，f[1]=1，且对所有n≥2有f[n]=(f[n-1]+f[n-2])%7。那么f[2025]的值是？

• A. 2
• B. 4
• C. 5
• D. 6

答案：D

递推数列周期分析（模运算周期性）：

递推数列在模固定数（此处为7）时，必然存在周期（因状态数有限：(f[n-1]%7, f[n-2]%7) 最多有7×7=49种状态）。

步骤1：找周期（计算前几项至重复初始状态）

f[0]=1, f[1]=1
f[2]=(1+1)%7=2，f[3]=(2+1)%7=3，f[4]=(3+2)%7=5，f[5]=(5+3)%7=1
f[6]=(1+5)%7=6，f[7]=(6+1)%7=0，f[8]=(0+6)%7=6，f[9]=(6+6)%7=5
f[10]=(5+6)%7=4，f[11]=(4+5)%7=2，f[12]=(2+4)%7=6，f[13]=(6+2)%7=1
f[14]=(1+6)%7=0，f[15]=(0+1)%7=1，f[16]=(1+0)%7=1

• 注意到 f[16]=f[0] 且 f[17]=f[1]，因此周期为 16。

步骤2：计算2025在周期中的位置

2025 ÷ 16 = 126 余 9 → 即 f[2025] = f[9]

• 由上述计算，f[9]=6，因此答案为D。

9. 下列关于C++ string类的说法，正确的是？

• A. string对象的长度在创建后不能改变。
• B. 可以使用+运算符直接连接一个string对象和一个char类型的字符。
• C. string的length()和size()方法返回的值可能不同。
• D. string对象必须以’\0’结尾，且这个结尾符计入length()。

答案：B

string类特性分析（逐一排除）：

• A错误：string是动态字符串，可通过push_back()、+=、resize()等操作修改长度（如string s="a"; s+="b";后s长度为2）。
• B正确：C++支持string + char的重载（如string s="abc"; char c='d'; s+c结果为"abcd"）。
• C错误：length()和size()是同义词，均返回string中有效字符的个数（不含内部隐藏的\0）。
• D错误：string对象内部无需显式存储\0（C风格字符串需\0结尾），length()也不计数\0。

10. 考虑以下C++函数，main函数调用solve后，x和y的值分别是？

void solve(int &a, int b) {
   
     // a是引用（绑定实参），b是值传递（拷贝实参）
    a = a + b;               // 修改引用a，同步影响实参
    b = a - b;               // 修改拷贝b，不影响实参
    a = a - b;               // 再次修改引用a
}
int main(){
   
   
    int x=5, y=10;
    solve(x, y);  // 实参x绑定a，实参y拷贝给b
}

• A. 5, 10
• B. 10, 5
• C. 10, 10
• D. 5, 5

答案：C

引用与值传递分析（逐句跟踪）：

1. 调用solve(x,y)时：

   • a 是x的引用（a与x占用同一内存）；
   • b 是y的拷贝（b初始值=10，与y无关）。

2. 执行solve内部逻辑：

   • 第1步：a = a + b → a = 5 + 10 = 15 → 同步x=15；
   • 第2步：b = a - b → b = 15 - 10 = 5 → y仍为10（b是拷贝）；
   • 第3步：a = a - b → a = 15 - 5 = 10 → 同步x=10。

3. 最终结果：x=10，y=10。

11. 8×8棋盘，左上角(1,1)，右下角(8,8)。机器人从(1,1)出发，每次只能向右或向下走一格，到达(4,5)有多少种不同路径？

• A. 20
• B. 35
• C. 56
• D. 70

答案：B

路径计数分析（组合模型）：

从(1,1)到(4,5)，需满足：

• 向下走：行从1→4，共4-1=3步（记为D）；
• 向右走：列从1→5，共5-1