NOIP2012模拟题一(c++)

NOIP2012模拟题一

一．不定项选择题（每题1.5分，共30分，多选少选都不得分）

1．现有一后缀表达式为5□□7□□4 －* 7 □□6□□2 / －5 + +（□为空格，数与数之间用空格隔开），请选出与该后缀表达式结果相等的选项（）

（A）（0！+0！+0！+0！）！（B）P44（C）（11001）2

（D）5*7－4+7－6/2+5 （E）（19）H

2．下面的描述属于线性表的有（）

（A）优先队列（B）栈（C）串

（D）堆（E）循环链表

3．下面的描述有采用贪心算法的是（）

（A）01背包问题（B）Prim算法（C）求最小生成树（D）Floyed算法（E）随机化快排

4．某移动硬盘容量是40G，那么它能存储多少张1024*1024的BMP图片( )

（A）40 （B）20480 （C）320

（D）327680 （E）320000

5．下列哪些选项是右图的拓扑序列（）

（A）0123456789

（B）1402365789

（C）023*******

（D）021*******

（E）0123564789

6．下面的描述有采用分治策略的是（）

（A）二分查找（B）快速排序（C）二路归并排序（D）二分答案（E）排序二叉树的查找操作

7．下面的算法复杂度为O（nLog2 n）的有（）

（A）冒泡排序（B）选择排序（C）插入排序

（D）二分查找一个元素（E）以中间元素作为关键字的快速排序

8．下面的描述有采用并查集算法的是（）

（A）Kruskal求最小生成树（B）Dijkstra求最短路径（C）Hash查找（D）求二叉树的中序遍历（E）求中缀表达式的值

9．算法的基本结构有( )

（A）顺序（B）选择（C）判断

（D）循环（E）重复

10．假设一棵二叉树的后序遍历序列为DGJHEBIFCA，中序遍历序列为DBGEHJACIF，则其前序遍历序列为。

A. ABCDEFGHIJ

B. ABDEGHJCFI

C. ABDEGHJFIC

D. ABDEGJHCFI

11．在下列4个不同数制表示的数中，最大的一个数是__________。

A．十进制数100 B．二进制数100 C．八进制数100 D．四进制数100 12．在PASCAL语言中，表达式15 div 4 + 15 mod -2 的值是。

A ． 1

B ． 2

C ． 3

D ． 4

13．链表不具有的特点是 。

A ．可随机访问任一元素

B ．插入删除不需要移动元素

C ．不必事先估计存储空间

D ．所需空间与线性表长度成正比

14． 在有n 个叶子结点的哈夫曼树中，其结点总数为 。

A ．不确定

B ．2n

C ．2n+1

D ．2n-1

15． 任何一个无向连通图的最小生成树 。

A ．只有一棵

B ．有一棵或多棵

C ．一定有多棵

D ．可能不存在

16． 二分查找法要求查找表中各元素的键值必须是 排列。

A ．递增或递减

B ．递增

C ．递减

D ．无序

17． 某二叉树的先序序列和后序序列正好相反，则该二叉树一定是 的二叉树。

A ．空或只有一个结点

B ．高度等于其结点数

C ．任一结点无左孩子

D ．任一结点无右孩子

18． 数组A ［l ．．5，1．．6］的每个元素占5个单元，将其按行优先次序存储在起始地址为lOOO 的连续的内存单元中，则元素A[5，5]的起始地址为 。

A ．1140

B ．1145

C ．1120

D ．1125

19．求最短路径的FLOYD 算法的时间复杂度为 。

A ．O(n)

B ．O(n+e)

C ．O(n2)

D ．O(n3)

20．一个栈的输入序列为1 2 3 4 5，则下列序列中不可能是栈的输出序列的是 。

A ． 2 3 4 1 5

B ． 5 4 2 3 1

C ． 2 3 1 4 5

D ． 1 5 4 3 2

二． 回答问题（每题5分，共10分）

1. 写出右图的二叉树的前序、中序、后序的遍历结果

前序：

中序：

后序：

2. 设正整数m,n ，1≤m,n ≤2012,且

()222m nm n --=1,求()m n 2

2+的最大值。

三． 阅读程序（每题8分，共32分）

1. #include

#include

using namespace std;

int main(){

int n=8,i,j,a[30];

for (i=0;i<=n;i++) a[i]=0;

a[1]=1;cout<

for (i=2;i<=n;i++){

for (j=i;j>=1;j--)

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

for (j=1;j<=i-1;j++)

cout<

cout<

}

return 0;

}

2. #include

#include

using namespace std;

int a[10],n=10;

void down(int m,int x){

int i=m,f,t;

while (2*i<=x){

if ((2*i+1)<=n && a[2*i]

else f=2*i;

if (a[i]

t=a[i];

a[i]=a[f];

a[f]=t;

}

i=f;

}

}

void adjust(int m){

int i,f,t;

for (i=m;i>=2;i--){

if ((i/2==(i-1)/2)&&(a[i]

else f=i;

if (a[f]>a[f/2]) down(f/2,n);

}

}

int main(){

int i;

for (i=1;i<=n;i++) cin>>a[i];

adjust(n);

cout<

for (i=n;i>=2;i--){

a[1]=a[i];

down(1,i-1);

cout<

}

cout<

return 0;

}

输入：7 3 4 1 8 9 10 2 5 6

3. #include

#include

using namespace std;

int x,y,z;

void silly(int x,int * y){

x=5;*y=6;z=3;

cout<

}

int main(){

x=1;

int * y;

y=new int;

*y=2;

z=3;

silly(x,y);

cout<

return 0;

}

4. #include

#include

#include

using namespace std;

set flag;

int a[10],s,n,m;

void t(int dep){

int i,j;

set::iterator iter;

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

iter=flag.find(i);

if (*iter!=i){

flag.insert(i);

a[dep]=i;

if (dep==m) s++;

else t(dep+1);

flag.erase(i);

}

}

return ;

}

int main(){

cin>>m>>n;

flag.clear();

s=0;

t(1);

cout<

return 0;

}

输入：4 5

四．程序填空（前六空每空2分，后四空每空4分，共28分）1.输入N个长整型数，再输入M个区间[A,B],求出这个区间内的最大值和最小值。

输入格式:

第一行输入N M(N<=10^6,M<=1000,N和M之间有一个空格)

第二行输入这N个长整型数

接下来的M行,输入区间[A,B]

输出格式:

输出M行,每行包含两个数,第一个数是最大值,第二个数是最小值,数与数之间有空格

例如:

输入:

5 3

3 2 6 9 1

1 5

2 5

3 4

输出:

9 1

9 1

9 6

#include

#include

#include

using namespace std;

int arr[1000000];

void search(int left,int right,int * max,int * min){

int mid;

int *maxL,*minL,*maxR,*minR;

maxL=new int;

minL=new int;

maxR=new int;

minR=new int;

if (left==right){

*max=arr[left];*min=arr[left];

}

else if (right==left+1)

if (arr[left]>arr[right]){

*max=arr[left];

*min=arr[right];

}

else{

___(1)___

*min=arr[left];

}

else{

___(2)___

search(left,mid,maxL,minL);

___(3)___

if(*maxL>*maxR) *max=*maxL;

else *max=*maxR;

___(4)___

}

}

int main(){

int n,i,j,a,b,m;

int *maxx,*minn;

maxx=new int;

minn=new int;

cin>>n>>m;

for (i=1;i<=n;i++) cin>>arr[i];

for (i=1;i<=m;i++){

cin>>a>>b;

___(5)___

cout<<*maxx<<" "<<*minn<

}

return 0;

}

2.最小的0、1数字串

[问题描述]

给定一个位数小于5的正整数N，编程求出最小正整数M，使N×M的各位数字均为0 或1。

例如，当N=6时，M=185，N×M=1110。

[问题输入]

输入文件名为str.in，仅一行，包含一个正整数N。

[问题输出]

输出文件为str.out，也只有一行，共有三个正整数，其中第一个数为N的值，第二个数为M的值，第3个数为M×N 的值。每两个相邻数之间严格以一个空格作为分隔。

[输入样例] str.in

6

[输出样例] str.out

6 185 1110

[问题分析]

首先想到的是穷举二进制01串，但这样做肯定会超时，因为复杂度是2的幂次,幂次为要求的最小01串的位数，如果01串的位数较大，还要用精度运算来处理。正确的方法是根据二进制01串(作为十进制数运算)除以n的余数进行递推,因为如个两个位数相同的01串除以n的余数相同的话，则在它们的最高位之前再加个1之后,两个新的01串除以n的余数仍然相同，而题目要求能被n整除的取小的01串，显然当两个不同的01串除以n的余数相同时，只需记录值较小的那个01串。

以n=6为例，0,1除以6的余数乃为0,1，在0之前加1得到10，10除以6的余数为4，在1之前加1得到11，11除以6的余数为5，然后再在00,01,10,11之前加1得到三位0,1串100,101,110,111，100除以6的余数与10除以6的余数同为4,则无须记录，同样地101除以6的余数与11除以6的余数同为5也无须记录，110除以6的余数为2，111除以6的余数为3，断续下去可推得四位的0,1串1000,1001,1010,1011除以6的余数均已在前面出现过，只有1110能被6整除，余数为零为问题的解。

在递推过程中对余数相同的01串只记录值最小的一个，所以象1100这样的01串就不会被处理到，因为1100是在100之前加上1得到的，而100在之前因为除以6的余数与10除以6的余数相同，没有记录下来，这样做会不会影响问题的解呢？答案是肯定不会，因为在010之前加上1得到的1010与1100一定有同样的余数，所以记录了1010就不需要考虑1100了。因为余数不会超过n，程序中要记录的01串当然不会超过n个，所以该算法的复杂度=要求的最小01串的位数*n。再利用mod运算的下列两个性质： (a*b) mod n=(a mod n)*(b mod n)，10^k mod n=(...(((10 mod n)*10) mod n)*10...) mod 10，高精度运算就可以避免了，实际上由于每一个01串都是通过在另一个串的头上添加1得到，所以我们可以将这样的一对01串看作父子关系，可用类似宽度优先的方法记录父结点，再记录下当前的01串的位数就可以了。细节请参源程序。

[参考程序]

#include

#include

#include

using namespace std;

int main(){

int maxn=10000,i,k,n,len,r,tempf,templ,x,Long[10000],father[10000];

bool firstz;

cin>>n;

if (n==1) {

cout<<1<<" "<<1<<" "<<1<

return 0;

}

for (i=0;i<10000;i++){

Long[i]=0;

father[i]=0;

}

Long[0]=0;Long[1]=1;

father[1]=0;

r=1;len=1;

while (___(1)___){

r=r*10%n;

len++;

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

if (___(2)___){

k=i+r;

if (k>=n) k=k-n;

if (Long[k]==0) {

Long[k]=len; ___(3)___; }

}

}

cout<

k=father[0];tempf=k;templ=len;

father[0]=-1;Long[0]=0;r=0;firstz=true;

while (k>=0){

r=r*10+1;

if (r/n>0){

cout<

}

if (r/n==0&&!firstz) cout<<0;

r=r%n;

for (i=len-1;i>=___(4)___;i--){

r=r*10;

if (r/n>0) {cout<

if (r/n==0&&!firstz) cout<<0;

r=r%n;

}

___(5)___;

k=father[k];

}

cout<<" ";

k=tempf;len=templ;

father[0]=-1;Long[0]=0;

while (k>=0){

cout<<1;

for (i=len-1;i>=Long[k]+1;i--) cout<<0;

len=Long[k];

k=father[k];

}

cout<

return 0;

}