（ ）是一种通用的字符编码，它为世界上绝大部分语言设定了统一并且唯一的二进制编码，以满足跨语言、跨平台的文本交换。目前它已经收录了超过十万个不同字符。

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

二分图是指能将顶点划分成两个部分，每一部分内的顶点间没有边相连的简单无向图。那么，12个顶点的二分图至多有（ ）条边。

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

对一个 n 个顶点、m 条边的带权有向简单图用 Dijkstra 算法计算单源最短路时，如果不使用堆或其它优先队列进行优化，则其时间复杂度为（ ）。

下面的故事与（ ）算法有着异曲同工之妙。

从前有座山，山里有座庙，庙里有个老和尚在给小和尚讲故事：从前有座山，山里有座庙，庙里有个老和尚在给小和尚讲故事：‘从前有座山，山里有座庙，庙里有个老和尚给小和尚讲故事....’?

1948年，（ ）将热力学中的熵引入信息通信领域，标志着信息论研究的开端。

二叉查找树具有如下性质：每个节点的值都大于其左子树上所有节点的值、小于其右子树上所有节点的值。那么，二叉查找树的（ ）是一个有序序列。

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

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

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

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

斐波那契数列的定义如下：F1=1,F2=1,Fn=Fn–1+Fn–2(n≥3)。如果用下面的函数计算斐波那契数列的第 n 项，则其时间复杂度为（ ）。

int F(int n)

{

if(n<=2)

return 1;

else

return F(n-1)+F(n-2);

}

T(n)表示某个算法输入规模为 n 时的运算次数。如果 T(1)为常数，且有递归式T(n)=2*T(n/2)+2n，那么 T(n)=（ ）。

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

CCF NOIP 复赛考试结束后，因（ ）提出的申诉将不会被受理。

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

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

（ ）属于 NP 类问题。

以 A0 作为起点，对下面的无向图进行深度优先遍历时（遍历的顺序与顶点字母的下标无关），最后一个遍历到的顶点可能是（  ）。

#include<iostream>
using namespace std;

int main( )
{
	int a,b,u,v,i, num;
	cin >>a>>b>>u>>v;
	num =0;
	for ( i= a; I <=b; i++)
		if (((i%u) ==0)||((i%v)==0))
			num ++;
		count <<num<<endl;
	return 0;
}

输入：1 1000 10 15

输出：_________

#include<iostream>
#include<string >
using namespace std;

const int SIZE = 100;
int n, m, p, a[SIZE] [SIZE], count;

void colour (int x, int y)
{
	Count++;
	a[x][y] = 1;
	if ((x > 1)&& (a[x-1][y] == 0))
		colour( x - 1, y);
	if ((y> 1)&& (a[x][y-1] == 0))
		colour( x, y- 1);
	if ((x < n)&& (a[x+1][y] == 0))
		colour( x +1, y);
	if ((y < m)&& (a[x][y+1] == 0))
		colour( x, y+1);
}
int main( )
{
	int i, j, x, y, ans;
	memset(a, 0, sizeof(a));
	cin >>n>>m>>p;
	for(i =1 ; I <=p; i++) {
		cin>>x>>y;
		a[x][y] = 1;
	}
	ans = 0;
	for (i =1; i <=n; i++)
		for (j =1; j <=m;j++)
			if (a[i][j] == 0)
				{count = 0;
				colour (i , j);
				if (ans <count)
					ans <count;
			}
	count<<ans<<endl;
	return 0;
}

输入：

6 5 9

1 4

2 3

2 4

3 2

4 1

4 3

4 5

5 4

6 4

输出：_________

某系统自称使用了一种防窃听的方式验证用户密码。密码是n个数s1,s2,…,sn，均为0或1。该系统每次随机生成 n 个数 a1,a2,…,an，均为 0 或 1，请用户回答(s1a1+s2a2+…+snan)除以2的余数。如果多次的回答总是正确，即认为掌握密码。该系统认为，即使问答的过程被泄露，也无助于破解密码——因为用户并没有直接发送密码。

然而，事与愿违。例如，当 n=4 时，有人窃听了以下 5 次问答：

就破解出了密码 s1=_________，s2=_________，s3=_________，s4=_________。

#include<iostream>
#include<string >
using namespace std;

int main( )
	{ string
	Str;
	cin>>str;
	int n = str.size( );
	bool isPlalindrome = true;
	for (int i =0; i<n/2;i++){
		if (str[i] !=str[n-i-1]) isPlalindrome = false;
	}
	if(isPlalindrome)
		cout << ”Yes” << endl;
	else cout << ”No” << endl;
}

输入：abceecba

输出：_________

现有一只青蛙，初始时在 n 号荷叶上。当它某一时刻在 k 号荷叶上时，下一时刻将等概率随机跳到1,2,…,k 号荷叶之一上，直至跳到1号荷叶为止。当n=2 时，平均一共跳2次；当 n=3 时，平均一共跳 2.5 次。则当 n=5 时，平均一共跳_________次。

#include<iostream>
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 = 1; i<n; i++){
			if(num[i] >ans) ans =num[j];
		}
		Cout <<ans<<endl;
}

输入：

8

3 2 5 11 12 7 4 10

6

输出：_________

（两元序列）试求一个整数序列中，最长的仅包含两个不同整数的连续子序列。如有多个子序列并列最长，输出任意一个即可。例如，序列“1 1 2 3 2 3 2 3 3 1 1 1 3 1”中，有两段满足条件的最长子序列，长度均为7，分别用下划线和上划线标出。

#include <iostream>

using namespace std;

int main()

{

const int SIZE = 100;

int n, i, j, a[SIZE], cur1, cur2, count1, count2,

ans_length, ans_start, ans_end;

//cur1, cur2 分别表示当前子序列中的两个不同整数

//count1, count2 分别表示 cur1, cur2 在当前子序列中出现的次数

cin>>n;

for (i = 1; i <= n; i++)

cin>>a[i];

i = 1;

j = 1;

//i, j 分别表示当前子序列的首尾，并保证其中至多有两个不同整数

while ((j <= n) && (a[j] == a[i]))

j++;

cur1 = a[i];

cur2 = a[j];

count1 =      (1)      //（3 分）

count2 = 1;

ans_length = j - i + 1;

while (j < n) {

j++;

if (a[j] == cur1)

count1++;

else if (a[j] == cur2)

count2++;

else {

if (a[j - 1] ==      (2)      ) { //（3 分）

while (count2 > 0) {

if (a[i] == cur1)

count1--;

else

ount2--;

i++;

}

cur2 = a[j];

count2 = 1;

}

else {

while (count1 > 0) {

if (a[i] == cur1)

                                                                      (3)                //（2 分）

else

                                                                       (4)             //（2 分）

i++;

}

                                        (5)           //（3 分）

count1 = 1;

}

}

if (ans_length < j - i + 1) {

ans_length = j - i + 1;

ans_start = i;

ans_end = j;

}

}

for (i = ans_start; i <= ans_end; i++)

cout<<a[i]<<' ';

return 0;

}

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

Const int SIZE = 100;

int a[SIZE],n;

它记录着一个长度为 n 的序列a[1],a[2],…,a[n]。

现在需要一个函数，以整数 p(1≤p≤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[      ( 1)      ] = a[i]; //（2 分）

for (i = p + 1; i <= n; i++)

b[i - p] = a[i];

for (i = 1; i <= n; i++)

a[i] = b[i];

 }

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

void swap2(int p)

{

int i, j, temp;

for (i = p + 1; i <= n; i++) {

temp = a[i];

for (j = i; j >=       (2)       ; j--) //（2 分）

a[j] = a[j - 1];

                    (3)        = temp; //（2 分）

  }

}

事实上，还有一种更好的算法，时间复杂度为O(n)、空间复杂度为O(1)：

void swap3(int p)

{

int start1, end1, start2, end2, i, j, temp;

start1 = 1;

end1 = p;

start2 = p + 1;

end2 = n;

while (true) {

i = start1;

j = start2;

while ((i <= end1) && (j <= end2)) {

temp = a[i];

a[i] = a[j];

a[j] = temp;

i++;

j++;

}

if (i <= end1)

start1 = i;

else if (      (4)      ) { //（3 分）

start1 =      (5)      //（3 分）

endl =      (6)      //（3 分）

start2 = j;

}

else

break;

}

}