noip普及组复赛模拟试题33（答案）

陶陶很喜欢数学 ，尤其喜欢奇怪的数。一天，他突然发现，有的整数拥有的因子数是很有个性的，决定找到一个具有n个正因子数的最小的正整数。

例如：n=4，则m=6，因为6有4个不同正整数因子1，2，3，6；而且是最小的有4个因子的整数。 【输入文件】

仅一个数 n（1≤n≤60） 【输出文件】 仅一个数 m 【样例输入】 4

【样例输出】 6

var flag:boolean;x,t,n,i:longint; begin readln(n); x:=0;flag:=false; while not flag do begin x:=x+1;t:=0; for i:=1 to x do

if x mod i=0 then t:=t+1; if t=n then flag:=true; end;

writeln(x); end.

输入 12 输出 60 输入30 输出 720 输入 60 输出 5040 输入 45 输出 3600

2. 由文件给出n个1~30000的无序数正整数，其中1≤N≤10000,同一个正整数可能会出现多次，出现次数最多的整数称为众数，找出其中的众数及它出现的次数。输入格式：输入文件masses.in 第一行是正整数的个数N,第二行开始为N个正整数。输出格式：输出文件masses.out有若干行，每行两个数，第1个是众数，第2个是众数出现的次数。 样例输入：30

18 2 10 1 1 15 6 13 3 3 11 18 2 12 15 13 18 17 15 19 8 3 15 17 11 16 14 8 7 16 样例输出：15 4

var n,t,i,max:longint;g:array[1..30000]of integer; begin assign(input,'masses.in');reset(input);

assign(output,'masses.out');rewrite(output); readln(n);fillchar(g,sizeof(g),0); for i:=1 to n do begin read(t);inc(g[t]);end; max:=0;

for i:=1 to 30000 do

if g[i]>max then max:=g[i]; for i:=1 to 30000 do

if g[i]=max then writeln(i,' ',max); close(input);close(output); end.

输入25

2 14 12 3 21 995 3 995 2 3 4 3 995 11 995 10000 76 995 9 19 4 995 300 200 8 输出 995 6

输入 12 4 2 3 2 5 3 7 2 3 4 3 输出 2 4 3 4 输入200

62 52 6 17 97 63 37 17 37 70 46 57 24 89 33 10 40 7 1 81 79 88 89 94 32 34 30 47 45 27 41 64 39 55 96 76 94 97 73 8 43 42 42 60 40 38 53 90 69 9 36 62 24 99 24 4 89 6 62 85 81 29 53 19 29 49 73 36 30 94 35 1 78 84 100 56 64 34 54 16 7 79 11 48 44 42 98 16 98 49 37 70 5 81 36 4 69 7 45 22 64 31 45 82 17 57 72 6 34 62 97 79 56 6 13 73 48 47 99 64 71 17 65 46 85 98 94 33 73 87 32 27 6 41 12 84 62 59 79 90 92 14 84 68 91 65 47 41 95 1 8 30 48 100 24 78 86 1 72 18 32 28 71 18 15 17 32 85 41 18 3 9 81 90 52 66 67 10 31 28 98 52 91 39 96 17 53 55 76 18 53 64 11 53 10 28 5 9 94 9 输出 17 6 输入 300

46 60 99 89 23 71 83 32 50 54 71 46 83 89 58 93 94 59 10 74 60 68 58 75 7 79 51 42 96 28 76 62 41 1 33 48 81 1 30 77 64 42 20 18 1 36 14 29 5 72 29 51 29 93 55 92 51 24 63 91 85 13 72 17 10 77 54 24 46 74 49 76 22 33 9 16 11 27 6 36 29 61 62 75 24 9 84 61 2 30 32 50 57 41 27 55 24 26 91 54 43 10 80 22 28 40 36 24 67 25 88 70 93 49 64 14 18 59 100 43 96 72 58 9 88 75 84 75 16 5 77 84 39 25 42 90 1 43 53 85 16 37 40 24 91 80 94 40 20 83 35 79 85 92 93 12 40 21 11 9 85 95 43 69 38 31 29 41 76 97 60 97 89 19

70 21 75 19 9 38 80 13 95 95 34 2 40 62 67 30 5 23 93 95 26 68 84 34 12 16 97 25 13 16 8 70 11 17 67 51 71 97 86 80 65 1 22 87 53 21 11 99 87 14 67 24 61 51 60 36 37 40 28 21 17 59 87 34 24 1 49 79 42 14 66 8 5 86 42 99 40 6 2 71 5 12 97 23 87 95 89 36 30 20 43 48 29 97 24 1 95 95 69 29 85 97 86 17 54 24 2 64 57 95 61 32 36 82 38 52 42 85 30 24 91 47 32 40 57 61 输出 24 11

在n个一连串的方格内填写字母A或B，但相邻两格内不能都填B。求所有可能的填写方案数。例如，当n＝3，可能的方案有AAA、AAB、ABA、BAA、BAB等5种。输入N输出方案数。样例输入 15 输出 1597

var

n,m,s,i,j,count:longint; flag:boolean;

a:array[1..100] of integer; begin

writeln('input n:'); readln(n);

s:=1; count:=0;

for i:=1 to n do s:=s*2; for i:=0 to s-1 do begin m:=i;

for j:=1 to n do begin

a[j]:=m mod 2; m:=m div 2; end;

flag:=true;

for j:=1 to n-1 do

if (a[j]=1)and(a[j+1]=1) then begin flag:=false; break; end; if flag=true then count:=count+1; end;

writeln(count); end.

输入 8 输出 55 输入 20 输出 17711 输入 18 输出 6765 输入 12 输出 377

晚会上大家在玩一款“暴力摩托”的游戏，它拥有非常逼真的画面和音响效果，如疾驰而过的汽车呼啸声，摩托车的引擎声和转弯时轮胎与地面摩擦而产生的声音。而且它在游戏中加入了对抗成份，比赛中你可以使用拳、脚去干扰对方，使其落后于你，是不是很卑鄙啊? 游戏中千万不能手下留情，因为对手会主动攻

击你。如果遇到开摩托车的警察，虽然也可以对他踢上一脚，但可得小心点呀，万一被他们捉住了，那就 GAME OVER 啦!

当然了，车子总是要加油的咯，已知赛道长S公里（S≤10000整数，且为10的倍数），赛车的油耗Q=1，即1公里路耗1个单位的油。Q不变，赛车的油箱为无穷大，同时在沿途的任何地方都可以加油。 约定，每次加油的数量为整数，且为10的倍数，赛车的速度与赛车加油后的总油量有关。其关系如下表列出：

加油量 ≤10 （10，20 ] （20，30 ] （30，40 ] （40，+∞） 车速（公里/小时） 100 90 80 75 70

同时，汽车每加油一次需要耗费T分钟（T<=100不论加油多少，开始时的加油不计时间）

当S，T给出之后，选择一个最优的加油方案。使汽车以最少时间跑完全程。 例如：当S=40，T=6（分钟），加油的方案有许多种，列出一些： 1）起点加油40，用时40/75≈0.53小时

2）起点加油20，中途加20，用时20/90+20/90+6/60（化为小时）≈ 0.54 小时 [输入文件]

一行，为两个整数S、T。 [输出文件]

输出一行，为最少用时（保留二位小数） [输入样例] 40 6

[输出样例] 0.53

思路分析

当走到某一距离时，此时的最小用时，与后面的行程方案无关，也就是无后效性，符合动态规划的原则，将S以每10公里为一单位分成s div 10段，如s=40时，分法如下：

对应路段的最小用时用A数组存放。很显然A[1]=10/100，走到20公里处时的方案有：（1）从0公里处加20单位的油，所需最小用时为min=20/90；(2)先到10公里处，此时的最小用时为A[1]，然后再加能到20公里的油，这段路的最小用时为：（20-10）/100，该方案的一共用时：A[1]+(20-10)/100。取两种方案的最小用时存入A[2]，同样可以求出A[3]、A[4]的最小用时，从而推出动态方程：A[i]=min{t(0到i), A[1]+t(1到i), A[2]+t(2到i), ……,A[i-1]+t(i-1 到 i)}, 其中t(0到i)表示只在0公里处加油后，以后不再加油，t(1到i) 表示在10公里处加油后，以后不再加油, ……。

参考程序如下： var s,t,i,j:longint;

a:array[1..1000] of real; m,min:real; begin

assign(input,'car.in'); assign(output,'car.out'); reset(input); rewrite(output); readln(s,t);

for i:=1 to s div 10 do {在0处加油后不再加油，到 i的最小用时，用min 存放} begin

case i of

1:min:=10/100; 2:min:=20/90; 3:min:=30/80; 4:min:=40/75; else min:=i*10/70; end;

for j:=1 to i-1 do {分别求各种方案的最小用时数} begin

case i-j of

1:m:=10/100; 2:m:=20/90; 3:m:=30/80; 4:m:=40/75;

else m:=(i-j)*10/70; end;

m:=m+t/60;{从j到i的最小用时} if m+a[j]

writeln(a[s div 10]:0:2); close(input); close(output); end.

输入 120 11 输出 1.71 输入 3000 50 输出 42.86 输入 50 4 输出 0.66 输入 10000 100 输出 142.86

小晨的电脑上安装了一个机器翻译软件，他经常用这个软件来翻译英语文章。这个翻译软件的原理很简单，它只是从头到尾，依次将每个英文单词用对应的中文含义来替换。对于每个英文单词，软件会先在内存中查找这个单词的中文含义，如果内存中有，软件就会用它进行翻译；如果内存中没有，软件就会在外存中的词典内查找，查出单词的中文含义然后翻译，并将这个单词和译义放入内存，以备后续的查找和翻译。假设内存中有M 个单元，每单元能存放一个单词和译义。每当软件将一个新单词存入内存前，如果当前内存中已存

本文来源：https://www.bwwdw.com/article/nmto.html