CSP-J 初赛模拟卷3 题解

注：这套题是我初赛集训班的模拟题，洛谷上可能搜不着一模一样的原题。切勿当真

1.【 单选 】2 分

关于计算机编程语言，下列说法错误的是（B）

• A.机器语言就是01码语言
• B.C语言是面向对象语言
• C.Java是面向对象语言
• D.计算机唯一能直接理解并执行的语言是机器语言

题解：傻瓜题，不讲了

知识点总结：

（1）机器语言由01码构成，计算机可以直接理解并执行，无需编译

（2）C++、Java等语言是面向对象的语言

（3）C语言是面向过程的语言，是汇编语言和高级语言的一种过渡语言

2.【 单选 】2 分

存储器是用来存放（A）信息的主要部件。

• A.二进制
• B.十进制
• C.八进制
• D.十六进制

题解：计算机内部所有信息都是以二进制进行存储的。存储器属于计算机的硬件系统，肯定也是以二进制存储数据，只不过输出时会把二进制数据转成人类可读的样子

知识点总结：

（1）计算器内部所有信息都是以二进制进行存储的

（2）题干

3.【 单选 】2 分

计算机之父是（B）

• A.艾伦·图灵
• B.冯·诺伊曼
• C.莫奇莱
• D.比尔·盖茨

题解：注意区分：图灵是计算机科学之父，冯·诺伊曼是计算机之父

知识点总结：

（1）图灵是计算机科学之父

（2）冯·诺伊曼是现代计算机之父

（3）莫奇莱于1946年2月与美国宾夕法尼亚大学埃克特教授制造了世界上第一台电子计算机——ENIAC

（4）比尔·盖茨是美国微软公司创始人（Windows系统就是微软开发的）

4.【 单选 】2 分

在编程的时候，使用一个4个字节的数据类型定义了1024×2048=2097152个变量，请问大致使用了多少内存？（D）

• A.1MB
• B.2MB
• C.4MB
• D.8MB

题解：傻瓜题，不讲了

知识点总结：

（1）1字节(Byte,B)=8位(bit)

（2）1KB=1024(2^10)B

（3）1MB=1024KB=1048576(2^20)B

5.【 单选 】2 分

假设A=true，B=false，C=true，以下为真的是（B）(“^”是异或)。

• A.A^B^C
• B.A&(B^C)
• C.A^(B^C)
• D.A&B&C

题解：傻瓜题，不讲了

知识点总结：

（1）异或是两边相同为0，不同为1

（2）“&”和“&&”，“|”和“||”，“!"和“~”都有区别

（3）优先级：

         取反 > 左/右移 > 与 > 异或 > 或

6.【 单选 】2 分

#include<cstdio>
#include<iostream>
#include<cmath>
#include<string>
using namespace std;
int main(){
   string s;
   cin>>s;
   int len;
   cin>>len;
   while(s.size()<len) s="1"+s;
   cout<<s<<endl;
   return 0;
}

输入为“996111 1000000000”，输出中有（A）个字符‘1’。

• A.999999997
• B.999999994
• C.4
• D.1

题解：这个程序是往输入的字符串前加字符‘1’，使这个字符串的长度等于len，初始的字符串的长度为6，len=1000000000。假如字符串中不含1，输出的1的个数为1000000000-6=999999994。但是原字符串中还有三个字符1，所以这个结果还要加上3，选A

7.【 单选 】2 分

设x是任意输入的数，阅读下面的递归算法：

void dfs(long long x){
   if(x>9) dfs(x/10);
   printf("%lld",x%10);
}

请问递归算法结束之后输出的是什么？（D）

• A.将x翻转后输出
• B.将x除去个位以外的数输出
• C.将x除去最高位以外的数输出
• D.输出x

题解：此递归函数到底时实际上输出了最高位，然后往上返回，不断输出：先是次高位，然后是次高位的下一位……最后输出最低位，例：
输入：2013724（大于等于10，往下）

第一次：201372（大于等于10，往下）

第二次：20137（大于等于10，往下）

第三次：2013（大于等于10，往下）

第四次：201（大于等于10，往下）

第五次：20（大于等于10，往下）

第六次：2（小于等于10） 输出：2

返回：输出：0

返回：输出：1

返回：输出：3

返回：输出：7

返回：输出：2

返回：输出：4

也就是把x原样输出了

8.【 单选 】2 分

“32位微型计算机”中的32位是指（D）。

• A.微机型号
• B.内存容量
• C.存储单位
• D.机器字长

题解：傻瓜题，不讲了

知识点总结：题干就是

9.【 单选 】2 分

由n个节点组成的m棵树，有（A）条边。

• A.n–m
• B.n–m+1
• C.n–m–1
• D.n–1

题解：一棵n个节点的树有n–1条边，m棵树相当于将n棵树砍掉m–1条边，所以n个节点组成的m棵树，一共有n–1–(m–1)=n–m条边。

知识点总结：可以把题干记住，当作树的一个性质

10.【 单选 】2 分

二进制数011011111011转换成十六进制数是（B）。

• A.6FA
• B.6FB
• C.6EC
• D.5EA

题解：傻瓜题，不讲了

11.【 单选 】2 分

有七个小朋友排成一列，其中小明和小红不能站在相邻的位置，则有（A）种排列的方法。

• A.3600
• B.1800
• C.1800
• D.720

题解：既然小明和小红不能相邻，那么可以先排其他的五个人，有A(5,5)=120种排法，然后用插板法，五个人中有六个空（两边也可以站），有A(2,6)（6在下，2在上）=30种。综上，共有A(5,5)×A(2,6)=120×30=3600种排法

12.【 单选 】2 分

我们往一个数据结构内按先后顺序丢入数值5，7，9，3。等到所有数都丢进去之后，从该数据结构内按顺序取出数值，按先后顺序为3，5，7，9，请问可能是如下哪种数据结构？（B）

• A.队列
• B.栈
• C.小根堆
• D.链表

题解：取出数值的序列与丢入时正好是逆序，而栈的特性是先进后出，后进先出，所以选B

知识点总结：

（1）队列的特性是先进先出，只允许一端进行插入（入队），一端进行删除（出队）

（2）栈的特性是先进后出，后进先出，只允许一端进行插入和删除

（3）小顶堆属于堆，每个结点都小于它的左右孩子。堆实际上是一棵二叉树

（4）链表属于链式存储，栈和队列属于线性存储

13.【 单选 】2 分

一棵高度为10的二叉树，最多具有（D）个节点。

• A.512
• B.511
• C.255
• D.1023

题解：傻瓜题，不讲了

知识点总结：一棵高度为n的二叉树至少有n个结点，至多有(2^n)-1个结点

14.【 单选 】2 分

Internet中运输层适合可靠性要求高的通信协议是（C）

• A.UDP
• B.IPC
• C.TCP
• D.FTP

题解：运输层协议有两个不同的协议：UDP与TCP，其中TCP可靠性高于UDP，故选C

知识点总结：

（1）题干

（2）UDP是用户数据报协议

（3）TCP是传输控制协议，可靠性要高于UDP

15.【 单选 】2 分

一个小于等于10^9的数，最多有（C）个不同的质因子。

• A.7
• B.8
• C.9
• D.29

题解：最小的9个不同的质因子的乘积为2×3×5×7×11×13×17×19×23=223092870，再乘一个质因子就大于109了，所以最多为9。

16.【 单选 】2 分

抽奖箱子里装了4个红色的球、5个黄色的球、6个蓝色的球，如果蒙眼去摸，为保证取出的球中有两个球的颜色相同，则最少要取出多少个球？（C）

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

题解：既然要保证两个球颜色相同，那么可以考虑最坏情况，假设每一次拿的球的颜色都不相同，假设有n种颜色的球，先拿n次，把每种颜色的球都拿走了一个。此时再拿一个颜色一定和已经拿出来的某个球的颜色相同

17.【 填空 】15 分

1）如果输入的数大于等于10^100（古戈尔）会出现数组越界的情况。 B

A.√

B.×

2）如果输入一个long long范围以内的数字，那么输出的数字相当于将输入的数字翻转后输出。 B

A.√

B.× 

3）将第9行“while(x)”改成“while(x>0)”，并在第13行之前加上一句“x=0;”，程序运行的结果不会改变。 A

A.√

B.× 

4）假设输入的数字在long long范围以内，如果输出的数字为0，那么输入的数字只能是0。

A.√

B.× 

5）若输出的数字为“998244353”，则下列说法正确的是 C 。
A、输入可以是99824435300
B、输入可以是3534428991
C、输入可以是3534428990000
D、输入只能是353442899

题解：

（1）longlong类型的取值范围为 ( -9223372036854775808~9223372036854775807)，大约是10^19，无符号的longlong类型也只能表示0~18446744073709551616，约是10^19×2，古戈尔肯定输入时会输入错误

（2）此错题可能是忘了考虑末尾有0的情况，末尾有0是会把0去除后输出的

（3）while(x)是把x看作真或假，当x一直除，直到x为0时退出，因为0就相当于假，非0就相当于真；while(x>0)则是当x>0这个表达式的值为假时退出。不难看出，这两条语句的作用是相同的

（4）这题是个傻瓜题，不讲了

（5）输入3534428990000，最后末尾的0会被舍弃，不会输出0000998244353这样的数。A和B肯定不对，两个数翻转过后与输出不同。D太绝对了，末尾有0也会直接舍弃，不输出

18.【 填空 】18 分

1.判断题：
1）若输入的N的大小为106，会发生数组越界的情况。B

A.√

B.×

2）假设输入的N是不超过105的正整数，输入的a[i].val都是int范围以内的正整数。输出N时，N一定大于sum。A

A.√

B.× 

3）假设输入的N是不超过105的正整数，输入的a[i].val都是int范围以内的正整数。输出的ans值一定是小于n值的。B

A.√

B.×  

4）输入的a[i].val都是int范围以内的正整数。若输入的N的值等于105，输入的a[1].val=1，输入的a[i].val(1≤i≤N-1)等于a[1].val+a[2].val+......+a[i–1].val+1，则输出的ans值等于 D 。
A、105−1
B、2×105
C、2×105−1
D、105

5）假定内存空间无限大的时候，如果将第7行的maxN改成maxN=2e9，现在第一行输入536870912(=229)，第二行输入536870912个1，最后输出的ans值等于 B。
A、29
B、30
C、536870912
D、536870911

6）假设输入的N是不超过105的正整数，输入的a[i].val都是int范围以内的正整数。若输入的a[N].val=1，输入的a[i].val(1≤i≤N-1)等于a[i+1].val+a[i+2].val+......+a[N].val，则输出的ans值等于 A 。
A、N
B、N–1
C、1+(log2N)(向上取整)
D、1+(log2N)(向下取整)

题解：

  这个程序在生成一棵二叉树

（1）当输入为N个节点的时候，新生成的节点为N-1个，于是有2×N–1个节点，当输入为100000个节点的时候，最终节点数刚好为199999个，所以数组大小为200000是够的。
（2）由于点的id值大的才会指向id值小的，且id小于等于n的节点只可能被指向，所以最后一定是形成一棵树的，该树有N个节点，有sum条边，所以sum=N–1，于是可以说N一定是大于sum的。
（3）当n=1的时候，输出的ans值是可以等于n的。
（4）由于输入的a[i].val=a[1].val+a[2].val+......+a[i–1].val。于是不难发现，建树的操作一定是1节点和2节点连接，他们新生成的节点和3节点连接，然后再新生成的节点和4连接，以此类推。所以，满足这样条件的，初始有1个节点的，最后ans就等于1，初始有N个节点的，ans就等于N。
（5）当值都相等的时候，不难发现，树是一棵完全二叉树，于是，树的第i层就有个节点，于是当指数为29的时候，形成的该二叉树的深度为30。
（6）因为在优先队列中满足出队的那个值一定是权值最小的，所以不难发现，本题与第25题实际上是形状类似的两棵树。

拓展知识点：

（1）operator是运算符重载，是C#、C++和pascal的关键字，它和运算符一起使用，表示一个运算符函数，理解时应将operator=整体上视为一个函数名。

（2）friend是友元函数。友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。类授予它的友元特别的访问权。通常同一个开发者会出于技术和非技术的原因，控制类的友元和成员函数（否则当你想更新你的类时，还要征得其它部分的拥有者的同意）。

19.【 填空 】17.5 分

（二叉树的中序遍历）给出正整数n，表示有n个节点，然后n–1行，每行两个小于等于n的正整数u、v，表示u点和v点之间连了一条边，现在知道该二叉树的根为1，求它的中序遍历。输入保证该树是一棵二叉树。每个点的左儿子应为子节点中下标小的那个节点。如果只有一个子节点的节点，该节点为左儿子。试补全程序。

1）①处应填 D。
   A、to[u].push_back(v);
   B、to[v].push_back(u);
   C、to[u].push_back(u);to[v].push_back(v);
   D、to[u].push_back(v);to[v].push_back(u);
2）②处应填 D。 
   A、if(to[u][0]>to[u][1])swap(to[u][0],to[u][1]);
   B、if(!to[u].empty())swap(to[u][0],to[u][1]);
   C、if(to[u][0]>to[u][1])swap(to[u][1],to[u][2]);
   D、sort(to[u].begin(),to[u].end());
3）③处应填 B。
   A、if(v==u)continue;
   B、if(v==fa)continue;
   C、if(op)continue;
   D、if(op>1)continue;
4）④处应填 B。
   A、if(!op)ans.push(u);
   B、if(op)ans.push(u);
   C、if(op==2)ans.push(u);
   D、if(i==1)ans.push(u); 
5）⑤处应填 C。
   A、if(op==0)ans.push(u);
   B、if(len<=2)ans.push(u);
   C、if(op<=1)ans.push(u);
   D、if(op==1)ans.push(u);

题解：

（1）尚未确定的方向的树需构造两条边，而且是互相构造，此处用动态数组构造邻接表

（2）因为需要满足题目，但是肯定有不满足的，所以要先排序，其他三个选项应该都是排序函数内部的交换语句，不完整

（3）因为建立图时是双向的，所以下一个结点是父节点时，就不能处理，直接退出

（4）如果已经访问了左孩子，在访问右孩子之前要输出u结点，并把它存进ans队列中

（5）有些情况会让答案里没有存下u这个结点，比如没有右孩子的时候，或者该结点为叶结点的时候，所以只需要判断它的子结点的个数是不是小于等于1就可以了。

20.【 填空 】17.5 分

（多重背包）有N种（N小于等于100）物品，你有容量为C（C小于等于100000）的背包，每种物品有num[i]（num[i]小于等于1000）个，且将它装入背包需要花费w[i]（w[i]小于等于100000）的容量以及获得v[i]（v[i]小于等于10000）的价值，现在我们想知道容量为C的时候的最大收获价值。试补全程序。

1）①处应填 C。
   A、a[++tot]=node(x*w[i],x*v[i]);
   B、a[++tot]=node(num[i]*w[i],num[i]*v[i]);x<<=1;
   C、a[++tot]=node(x*w[i],x*v[i]);x<<=1;
   D、a[++tot]=node(num[i]*w[i],num[i]*v[i]);x*=2;
2）②处应填 D。 
   A、if(x>=num[i])
   B、if(num[i]>1)
   C、while(num[i])
   D、if(num[i])
3）③处应填 B。 
   A、a[++tot]=node(x*w[i],x*v[i]);
   B、a[++tot]=node(num[i]*w[i],num[i]*v[i]);
   C、x-=num[i];a[++tot]=node(x*w[i],x*v[i]);
   D、num[i]-=x;a[++tot]=node(num[i]*w[i],num[i]*v[i])
4）④处应填 C。 
   A、for(int j=0;j<=C;j++)
   B、for(int j=a[i].w;j<=C;j++)
   C、for(int j=C;j>=a[i].w;j--)
   D、for(int j=C;j>=0;j--)
5）⑤处应填 D。 
   A、dp[j]=dp[j–a[i].w]+a[i].v;
   B、dp[j]=max(dp[j–1],dp[j–a[i].w]+a[i].v);
   C、dp[j+a[i].w]=max(dp[j+a[i].w],dp[j]+a[i].v);
   D、dp[j]=max(dp[j],dp[j-a[i].w]+a[i].v)

题解（DP我还没学，所以直接抄的，请谅解）：

（1）利用二进制优化的形式写多重背包，所以每次将一个物品变成x个物品，并且x每次乘以2，乘2的操作相当于左移一位，所以C是正确的。
（2）如果num[i]不能恰好被二进制划分完成，那么多余的，且不满足下一个x的，就是直接用num[i]个它做成一个物品就可以了。
（3）最后如果存在多余出来的num[i]个，需要将它们额外制成一个物品，所以相当于是num[i]个i物品了。
（4）现在相当于是在做01背包的过程，所以我们需要将for循环倒着写，避免每个物品被重复的取和拿了。
（5）此时，是用01背包求的是容量为j时候的，考虑前i个物品能得到最大价值。