NOIP 2013 普及组初赛试题

第 1 题

一个 32 位整型变量占用（A）个字节。

A. 4
B. 8
C. 32
D. 128

常识题，每个32 位整型变量占4个字节

第 2 题

二进制数 11.01 在十进制下是（A）。

A. 3.25
B. 4.125
C. 6.25
D. 11.125

进制转换（答案很明显）

第3题

下面的故事与（B）算法有着异曲同工之妙。 从前有座山，山里有座庙，庙里有个老和尚在给小和尚讲故事：“从前有座山，山里有座庙，庙里有个老和尚在给小和尚讲故事：‘从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事……’”

A. 枚举
B. 递归
C. 贪心
D. 分治

这句话一直在重复：从前有座山，山里有座庙，庙里有个老和尚在给小和尚讲故事。首先排除分治和贪心。其次我们发现他是一层一层地在重复着同一句话，所以不符合枚举的意思。只剩下递归。

第 4 题

逻辑表达式（C）的值与变量 A 的真假无关。

A. (A ∨ B) ∧﹃A
B. (A ∨ B) ∧﹃B
C. (A ∧ B) ∨ (﹃ A ∧ B)
D. (A ∨ B) ∧﹃A ∧ B

常识题

第 5 题

将 { 2 , 6 , 10 , 17 } \{2, 6, 10, 17\} {2,6,10,17} 分别存储到某个地址区间为 $0\sim 10$的哈希表中，如果哈希函数 h(x)= （D），将不会产生冲突，其中 $a\mathrm{mod}b$ 表示 a 除以 b 的余数。

A. $x\mathrm{mod}11$
B. $x^2\mathrm{mod}11$
C. $(2x)\mathrm{mod}11$
D. $\lfloor \sqrt{x}\rfloor \mathrm{mod}11$，其中$\lfloor \sqrt{x}\rfloor$表示 $\sqrt{x}$下取整

A,B,C,D分别是4个哈希函数，题目的要求是输入为（2,6,10,17）时，哈希函数的输出各自不相同，所以判断就行了

第6题

在十六进制表示法中，字母 $\text{A}$ 相当于十进制中的（B）。

A. 9
B. 10
C. 15
D. 16

第 7 题

下图中所使用的数据结构是（B）。

A. 哈希表
B. 栈
C. 队列
D. 二叉树

很明显，这道题是先进后出的，使用的是栈

第 8 题

在 Windows 资源管理器中，用鼠标右键单击一个文件时，会出现一个名为“复制”的操作选项，它的意思是（C）。

A. 用剪切板中的文件替换该文件
B. 在该文件所在文件夹中，将该文件克隆一份
C. 将该文件复制到剪切板，并保留原文件
D. 将该文件复制到剪切板，并删除原文件

常识题

第 9 题

已知一棵二叉树有 10 个节点，则其中至多有（A）个节点有 2 个子节点。

A. 4
B. 5
C. 6
D. 7

第 10 题

在一个无向图中，如果任意两点之间都存在路径相连，则称其为连通图。下图是一个有 4 个顶点、6 条边的连通图。若要使它不再是连通图，至少要删去其中的（ C）条边。

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

第 11 题

二叉树的（A）第一个访问的节点是根节点。

A. 先序遍历
B. 中序遍历
C. 后序遍历
D. 以上都是

先序遍历：根左右；中序遍历：左根右；后序遍历：左右根

第 12 题

以$A_0$作为起点，对下面的无向图进行深度优先遍历时，遍历顺序不可能是（A)

A.$A_0,A_1,A_2,A_3$
B.$A_0,A_1,A_3,A_2$
C.$A_0,A_2,A_1,A_3$
D.$A_0,A_3,A_1,A_2$

第 13 题

IPv4 协议使用 32 位地址，随着其不断被分配，地址资源日趋枯竭。因此，它正逐渐被使用（D)位地址的IPv6协议所取代

A. 40
B. 48
C. 64
D. 128

第 14 题

（A）的平均时间复杂度为 $O(n\log n)$，其中 n 是待排序的元素个数。

A. 快速排序
B. 插入排序
C. 冒泡排序
D. 基数排序

第 15 题

下面是根据欧几里得算法编写的函数，它所计算的是 a 和 b 的（C）。

int euclid(int a, int b)
{
if (b == 0)
return a;
else
return euclid(b, a % b);
}
1
2
3
4
5
6
7

A. 最大公共质因子
B. 最小公共质因子
C. 最大公约数
D. 最小公倍数
​

第 16 题

通常在搜索引擎中，对某个关键词加上双引号表示（C）。

A. 排除关键词，不显示任何包含该关键词的结果
B. 将关键词分解，在搜索结果中必须包含其中的一部分
C. 精确搜索，只显示包含整个关键词的结果
D. 站内搜索，只显示关键词所指向网站的内容

第 17 题

中国的国家顶级域名是（A）。

A. .cn
B. .ch
C. .chn
D. .china

想想NOI的网址

第 18 题

把 64 位非零浮点数强制转换成 32 位浮点数后，不可能（D）。

A. 大于原数
B. 小于原数
C. 等于原数
D. 与原数符号相反

第 19 题

下列程序中，正确计算 $1,2,\dots ,100$ 这 100 个自然数之和 $\mathrm{sum}$（初始值为 0）的是（A）。

A. i = 1 do{ sum +=i; i++; }while(i<=100);
B. i = 1; do{ sum +=i; i++; }while(i > 100);
C. i = 1; while(i < 100){ sum+=i; i++; }
D. i = 1; while(i >= 100){ sum+=i; i++; }

第 20 题

CCF NOIP 复赛全国统一评测时使用的系统软件是（B）。

A. NOI Windows
B. NOI Linux
C. NOI Mac OS
D. NOI DOS

第 21 题

7 个同学围坐一圈，要选 2 个不相邻的作为代表，有____14_____种不同的选法。

第 22 题

某系统自称使用了一种防窃听的方式验证用户密码。密码是 n 个数 $s_1,s_2...s_n$，均为 0 或 1。该系统每次随机生成 n 个数$a_1,a_2,\dots ,a_n$a，均为 0 或 1，请用户回答 $(s_1{a}_1+s_2{a}_2+\cdots +s_n{a}_n)$除以 2 的余数。如果多次的回答总是正确，即认为掌握密码。该系统认为，即使问答的过程被泄露，也无助于破解密码——因为用户并没有直接发送密码。
然而，事与愿违。例如，当 n =4 时，有人窃听了以下 5 次问答：

就破解出了密码s1 =___ ，s2 = ___，s3 =___ ，s4 =___。
答案格式为：纯数字用,连接

答案：0,1,1,1

第 23 题

阅读程序写结果：

#include 
using namespace std;
int main()
{
	int a, b;
	cin >> a >> b;
	cout << a << "+" << b << "=" << a + b << endl;
}
1
2
3
4
5
6
7
8

输入： 3 5
答案：3+5=8
很简单，直接模拟

第 24 题

阅读程序写结果：

#include  
using namespace std;
int main()
{
int a, b, u, i, num;
cin>>a>>b>>u; num = 0;
for (i = a; i <= b; i++) if ((i % u) == 0)
num++;
cout<<num<<endl; return 0;
}
1
2
3
4
5
6
7
8
9
10

输入： 1 100 15
答案：6
就是求a到b中能被u整除的数的数量

第 25 题

阅读程序写结果：

#include  
using namespace std;
int main()
{
const int SIZE = 100;
int n, f, i, left, right, middle, a[SIZE];
cin>>n>>f;
for (i = 1; i <= n; i++)
cin>>a[i]; left = 1;
right = n; 
do {
middle = (left + right) / 2; 
if (f <= a[middle])
right = middle;
else
left = middle + 1; 
} while (left < right); 
cout<<left<<endl;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

输入：
12 17
2 4 6 9 11 15 17 18 19 20 21 25
答案：7
求f在a数组中的位置

第 26 题

阅读程序写结果：

#include  
using namespace std;
int main()
{
const int SIZE = 100;
int height[SIZE], num[SIZE], n, ans;
cin>>n;
for (int i = 0; i < n; i++) 
{ 
cin>>height[i]; num[i] = 1;
for (int j = 0; j < i; j++) 
{
if ((height[j] < height[i]) && (num[j] >= num[i]))
num[i] = num[j]+1;
}
}
ans = 0;
for (int i = 0; i < n; i++)
 { 
 if (num[i] > ans) ans = num[i];
}
cout<<ans<<endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输入：
6
2 5 3 11 12 4
答案：4

第 27 题

完善程序： （序列重排）
全局数组变量 a 定义如下：

const int SIZE = 100;
int a[SIZE], n;
1
2

它记录着一个长度为 n 的序列 $a_1,a_2,\dots ,a_n$。
现在需要一个函数，以整数 $p(1\le p\le n)$ 为参数，实现如下功能：将序列 a 的前 p 个数与后 n-p 个数对调，且不改变这 p 个数（或 n−p 个数）之间的相对位置。例如，长度为 5 的序列 1,2,3,4,5，当 p=2 时重排结果为 3, 4, 5, 1, 2 。
有一种朴素的算法可以实现这一需求，其时间复杂度为 $O(n)$、空间复杂度为 $O(n)$：

void swap1( int p )
{
	int i, j, b[SIZE];
	for ( i = 1; i <= p; i++ )
		b[①] = a[i];             //  （3分）         
	for ( i = p + 1; i <= n; i++ )
		b[i - p] = ②;           //  （3分）    
	for ( i = 1; i <= ③; i++ )  //  （2分）
		a[i] = b[i];
}
1
2
3
4
5
6
7
8
9
10

我们也可以用时间换空间，使用时间复杂度为 $O(n^2)$、空间复杂度为 $O(1)$ 的算法：

void swap2( int p )
{
	int i, j, temp;
	for ( i = p + 1; i <= n; i++ )
	{
		temp = a[i];
		for ( j = i; j >= ④; j-- )    //  （ 3 分）
			a[j] = a[j - 1];
		⑤ = temp;                     // （ 3 分）
	}
}
1
2
3
4
5
6
7
8
9
10
11

答案：

1. n –p + i
2. a[i]
3. n
4. i -p + 1
5. a[i-p]

第 28 题

完善程序：
（二叉查找树） 二叉查找树具有如下性质： 每个节点的值都大于其左子树上所有节点的值、小于其右子树上所有节点的值。试判断一棵树是否为二叉查找树。
输入的第一行包含一个整数 n，表示这棵树有 n 个顶点， 编号分别为 $1,2,\dots ,n$，其中编号为 1 的为根结点。之后的第 i 行有三个数 $\mathrm{value},left\_child,right\_child$，分别表示该节点关键字的值、左子节点的编号、右子节点的编号；如果不存在左子节点或右子节点，则用 0 代替。输出 1 表示这棵树是二叉查找树，输出 0 则表示不是。

#include  
using namespace std; 
const int SIZE = 100;
const int INFINITE = 1000000;
struct node
{
	int left_child, right_child, value;
}; node a[SIZE];
int is_bst( int root, int lower_bound, int upper_bound )
{
	int cur;
	if ( root == 0 )
		return(1);
	cur = a[root].value;
	if ( (cur > lower_bound) && ( ① ) && (is_bst( a[root].left_child, lower_bound, cur ) == 1) && (is_bst( ②, ③, ④ ) == 1) )
		return(1);
	return(0);
}


int main()
{
	int i, n; cin >> n;
	for ( i = 1; i <= n; i++ )
		cin >> a[i].value >> a[i].left_child >> a[i].right_child;
	cout << is_bst( ⑤, -INFINITE, INFINITE ) << endl;
	return(0);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

答案：

1. cur
2. a[root].right_child
3. cur
4. upper_bound
5. 1

(最后那道题好难）