联赛模拟试题解答

模拟测试解答

试题一精度计算（20分）

[问题描述]

输入两个10000以内的正整数X、Y，求X除以Y的值。要求精确到小数点后100位，如果在100位内出现循环节，请用括号标出。如：51/7＝7.(285714)。

[样例一]

输入：

51 7

输出：

7.(285714)

[样例二]

输入：

21 7

输出：

[分析]

我们可以依次求出商的每一位数字。

首先直接输出商的整数部分，并将x赋值为x除以y的余数，然后计算商的小数部分，每次求商的一位数字，并记下当前余数出现的位置：若余数为零则表示能够除尽，退出计算；若余数重复出现，则表示出现循环节，记下循环节开始位置并退出计算。

最后将计算结果输出。

[参考程序]

const

limit =100; {精确位数最大为100位}

max =10000; {除数最大为10000}

var

x,y,len,st :longint; {被除数，除数，商小数部分的位数，循环节开始位置} s :array[0..limit+1] of longint; {商的小数部分}

posi :array[0..max] of longint;{不同余数出现的位置，未出现的标记为0}

procedure init; {输入}

begin

fillchar(s,sizeof(s),0); {数组s初始化}

fillchar(posi,sizeof(posi),0); {数组posi初始化}

len:=0;st:=0; {小数部分位数初始化，循环节开始位置初始化} read(x,y); {读入被除数x,除数y}

write(x div y); {输出商的整数部分}

x:=x mod y; {x取为余数的值}

end;{of init}

procedure work; {计算}

begin

if x=0 then exit; {若能整除则退出}

while len

begin

inc(len); {小数部分长度加1}

posi[x]:=len; {标记余数出现位置}

x:=x*10;

s[len]:=x div y; {求小数部分的第len位}

x:=x mod y; {求新余数}

if posi[x]<>0 then {判断该余数是否曾经出现}

begin

st:=posi[x]; {记下循环节开始位置}

break; {退出}

end;{of if}

if x=0 then break; {若能除尽退出}

end;{of while}

end;{of work}

procedure out; {输出}

var

i :longint;

begin

if len=0 then begin writeln;exit;end; {若能整除，换行、退出}

write('.'); {输出小数点}

if st=0 then {判断是否有循环节}

for i:=1 to len do write(s[i]) {没有循环节，直接输出小数部分} else begin {有循环节}

for i:=1 to st-1 do write(s[i]); {输出循环节以前的部分} write('('); {打印“（”}

for i:=st to len do write(s[i]); {输出循环节部分}

write(')'); {打印“)”}

end;{of else}

writeln;

end;{of out}

BEGIN {主过程}

init; {输入}

work; {计算}

out; {输出}

END.

试题二四色排列（30分）

[问题描述]

红、黄、蓝、绿4种颜色围成长度为N(N<=30)的一圈（位置编号为1、2、…、N），不能有一种颜色是连续3个，共有多少种方案？

[样例]

输入：5

输出：780

[分析]

先考虑4种颜色放成一排的情况。

状态s[n，0]为已放了n个颜色，结尾的两个颜色不相同的方案总数，s[n，1]

为已放了n个颜色，结尾的两个颜色相同的方案总数。

以n为阶段，状态转移方程为

s[n,0]=(s[n-1,0]+s[n-1,1])*3;

s[n,1]=s[n-1,0];

s[1,0]=4;

s[1,1]=0;

接下来考虑圈的情况。排列成圈和排列成排的情况唯一不同的是可能出现头尾相同的情况。

例如：123411，虽然排成一排满足题意，但排成圈后为

１１

１２

４３

出现了连续的三个相同颜色，便不满足题目中条件了。

经过分析不难看出，圈可能引起3种情况：

1开头的两个颜色相同，结尾有一个和开头相同的颜色。如1121

2开头有两个颜色相同，结尾有连续两个和开头相同的颜色。如11211

3开头有一个颜色，结尾有连续两个和开头相同的颜色。如1211

根据对称性可知，情况1和情况3的方案总数相同，因此我们只需求出情况1就可以得出情况3的方案总数。

因此我们可以利用补集转化思想，先求出排成一排的方案总数S，再求出圈所引起的特殊情况T，则题目所求的方案总数R=S-T。

现在的问题是如何求出T

类似地，记状态s2[n，p1,p2] （p1,p2∈{0,1})，表示已放了n个颜色，且开头两个颜色相同的方案总数。

这里，p1表示开头的颜色是否相同（0为不同，1为相同），p2 表示结尾两个颜色是否相同

（0为不同，1为相同）。

显然，情况1的总数为s2[n,1,0]，情况2的总数为s2[n,1,1].情况3的总数=情况1=s2[n,1,0] ;

以n为阶段

状态转移方程为

s2[n,0,0]=(s2[n-1,0,0]+s2[n-1,0,1])*2+(s2[n-1,1,0]+s2[n-1,1,1])*3;

s2[n,0,1]=s2[n-1,0,0];

s2[n,1,0]=s2[n-1,0,0]+s2[n-1,0,1];

s2[n,1,1]=s2[n-1,1,0];

s2[2,0,0]=0;

s2[2,0,1]=0;

s2[2,1,0]=0;

s2[2,1,1]=3;

当然n=1和n=2为特殊情况，需特殊处理。

另外，由于本阶段的状态只和上一阶段状态有关，所以只需保存上一个阶段的状态。因此采用循环数组存储状态。

[参考程序]

const

limit =31;

colors =4;

var

n,now1,now2 :integer;

s :array[0..1,0..1] of extended; //排成一排的方案总数

s2 :array[0..1,0..1,0..1] of extended; //由圈引起的特殊情况的总数

procedure init; // 初始化

begin

now1:=0;now2:=0;

s[0,0]:=colors; //s的边界条件。

s[0,1]:=0;

fillchar(s2,sizeof(s2),0);

s2[0,1,1]:=colors; //s2的边界条件。

read(n);

end;

procedure work;

var

i :integer;

begin

for i:=2 to n do //求出s。

begin

now1 :=1-now1;

s[now1,0]:=(s[1-now1,0]+s[1-now1,1])*(colors-1);

s[now1,1]:=s[1-now1,0];

end;

for i:=3 to n do //求出s2

begin

now2:=1-now2;

s2[now2,0,0]:=(s2[1-now2,0,0]+s2[1-now2,0,1])*(colors-2)+(s2[1-now2,1,0]+s2[1-n

ow2,1,1])*(colors-1);

s2[now2,0,1]:=s2[1-now2,0,0];

s2[now2,1,0]:=s2[1-now2,0,0]+s2[1-now2,0,1];

s2[now2,1,1]:=s2[1-now2,1,0];

end;

procedure out; //输出

begin

case n of

1: writeln(4); //因为n=1，n=2为特殊情况，所以特殊判断。

2: writeln(16);

else writeln(s[now1,0]+s[now1,1]-s2[now2,1,0]*2-s2[now2,1,1]:0:0);

end;

BEGIN

init;

work;

out;

END.

试题三最少步数（20分）

[问题描述]

在各种棋中，一种棋子的走法总是一定的，如中国象棋中马走“日”。有一位小学生就

想如果马能有两种走法将更加增加趣味性，因此，他规定马既能按“日”飞，也能各象一样

走“田”字。他的同桌平时喜欢下围棋，知道这件事后觉得很有趣，就和他玩一种新游戏，

在围棋盘上（19*19）任选两点A、B，A点放上黑子，B点放上白子，代表两匹马。棋子可

以按“日”字走，也可以按“田”字走，俩人一个走黑马，一个走白马。谁用最少的步数走

到左上角坐标为(1,1)的点时，谁获胜。现在他请你帮忙，给你A，B两点的坐标，想知道两

个位置到（1,1）点的可能最少步数。

12 16

18 10

[样例输出]

题解

由于A、B两点是随机输入的，因此无法找到计算计算最少步数的数学规律，只能通过广度优先搜索的办法求解。

1、确定出发点

从（x,y）出发通过一次广度优先搜索，可以找到从(x,y)至棋盘上所有可达点的最少步数。而问题中要求的是黑马所在的（x1，y1）和白马所在（x2，y2）到达(1,1) 目标点的最少步数。虽然两条路径的起点不一样，但是它们的终点却是一样的。如果我们将终点(1,1)作为起点，这样只需要一次广度优先搜索便可以得到（x1，y1）和（x2，y2）到达(1,1)的最少步数。

2、数据结构

设

queue——队列，存储从(1,1)可达的点（queue[k,1..2]）以及到达该点所需要的最少步数（queue[k,3]）（0≤k≤192）。队列的首指针为closed，尾指针为open。初始时，queue中只有一个元素为(1,1)，最少步数为0。

S——记录(1,1)到每点所需要的最少步数。显然，问题的答案是s[x1,y2]和s[x2,y2]。初始时，s[1,1]为0，除此之外的所有元素值设为-1。为了使得马从棋盘内任意位置扩展出的坐标均在s的范围内，我们将s数组的范围扩大至s[-1..21,-1..21]。

dx、dy——移动后的位置增量数组。马有12种不同的扩展方向：

马走“日”：(x-2,y-1)(x-1,y-2)(x-2,y+1)(x-1,y+2)(x+2,y-1)(x+1,y-2)(x+2,y+1)(x+1,y+2) 马走“田”：(x-2,y-2)(x-2,y+2)(x+2,y-2)(x+2,y+2)

我们将i方向上的位置增量存入常量数组(dx[i]、dy[i])中（1≤i≤12）

const

19 =19; {棋盘大小}

dx :array[1..12] of integer=(-2,-2,-1,1,2,2,2,2,1,-1,-2,-2);

dy :array[1..12] of integer=(-1,-2,-2,-2,-2,-1,1,2,2,2,2,1);

3、约束条件

⑴不能越出界外。由于马的所有可能的落脚点s均在s的范围内，因此一旦马越出界外，就将其s值赋为0，表示“已经扩展过，且(1,1)到达其最少需要0步”。这看上去是荒谬的，但可以简单而有效地避免马再落入这些界外点。

⑵该点在以前的扩展中没有到达过。如果曾经到达过，则根据广度优先搜索的原理，从前到达需要的步数一定小于现在到达该点所需要的，因此完全没有必要扩展。

由此得出跳后位置（x,y）是否可以入队的约束条件是s[x,y]<0

fillchar(s,sizeof(s),0); s[1,1]:=0; {s数组的初始化} for x1:=1 to 19 do

for y1:=1 to 19 do s[x1,y1]:=-1;

fillchar(que,sizeof(que),0); { 队列初始化} open:=1;closed:=0; {初始位置入队} que[1,1]:=1;que[1,2]:=1;

read(x1,y1,x2,y2); {读入黑马和白马所在位置} while closed

for d:=1 to 12 do begin {枚举8个扩展方向} x:=que[closed,1]+dx[d]; {计算马按d方向跳跃后的位置} y:=que[closed,2]+dy[d];

if s[x,y]<0 then {若（x,y）满足约束条件} begin

s[x,y]:=que[closed,3]+1; {计算(1,1)到(x,y)的最少步数} inc(open); {（x,y）和（1,1）至（x,y）的最少步数入队}

que[open,1]:=x; que[open,2]:=y; que[open,3]:=s[x,y];

end;{then}

end;{for}

end;{of while}

end; {of work}

writeln(s[x1,y1]); writeln(s[x2,y2]); {输出问题的解} 试题四打包（30分）

“搜索思想”和“分治思想”似乎对本题都不适合，前者的时间效率不佳，后者根本不适用，我们必须另谋它路。

如果让人来装箱的话，一般我们都会采用这样的策略：如果有6?6的盒子，则将它放入箱子，这个箱子就满了。这个过程直到6?6的盒子全部装箱为止。接着如果有5?5的盒子，则将它放入箱子，这个箱子还没放满，可以放入尽可能多的1?1盒子；这个过程直到6?6的盒子全部装箱为止。放4?4的盒子时，箱子中的剩余空间可以放2?2的盒子，如果还有剩余，则放1?1的盒子……

用简练的语言概括出这样一种策略：每次找最大的盒子放入当前的箱子，直到无法再放，拿一个空箱继续这一过程，直到所有的盒子都被装箱。这正是贪心思想的体现。

本题是可以用贪心思想解决的，下面证明我们的算法确实求出了最优解。

设f (a 1,a 2,a 3,a 4,a 5,a 6)为要装下a 1个1?1的，a 2个2?2的，……，a 6个6?6的盒子需要的箱子数。下面有几个等式：

(1)654321654321 ,0),,,,(),,,,,(a a a a a a f a a a a a a f +=

这是因为每一个6?6的盒子都刚好放入一个6?6的箱子（图0-0-1(a)）。

(2)54325154321 ,0)0,,,},a 11-,0(max{)0,,,,,(a a a a a f a a a a a f +?=

每一个5?5的盒子都需要一个箱子，但每个箱子放入一个5?5的盒子后还有6?6-5?5=11个单位的空间，而这些空间只能放1?1的盒子，最多放11个（图0-0-1(b)）。

(3)??

??<+?-??≥+?=4

324142434214

5 ,0)0,0,},0,)4(20-,0(max{5 ,0)0,0,,5-,()

0,0,,,,(a a a a a a a f a a a a a a a f a a a a f

每一个4?4的盒子都需要一个箱子，但每个箱子放入一个4?4的盒子后还有6?6-4?4=20个单位的空间。这些空间恰好可以放入5个2?2的盒子，或20个1?1的盒子。由于1?1的盒子可以“见缝插针”地放入，因此应该尽量先放2?2的盒子。a 4个4?4的盒子装箱可以得到5?a 4个2?2的空间。若a 2≥5?a 4，则这些空间全部用掉，否则剩下的空间还可以放1?1的盒子（图0-0-1(c)(d)）。

图0-0-1

(4)??

??????

???

????

=+?=+?=+?=+=1

4mod 4/ ,0)0,0,05},-max{0,})},min{5,4-(27-,0(max{24mod 4/ ,0)0,0,03},-max{0,})},min{3,4-(18-,0(max{34mod 4/ ,0)0,0,01},-max{0,})},min{1,4-(9-,0(max{0

4mod 4/ ,0)0,0,0,,()

0,0,0,,,(3322133221332213321321a a a a a f a a a a a f a a a a a f a a a a f a a a f 每个箱子可以放4个3?3的盒子。这样4个4个放完后，可能还多0, 3, 2, 1个，4种情况。与(3)同样的道理，还是先放2?2的盒子。这4种情况分别还能放0, 1, 3, 5个2?2的盒子。多余的空间放1?1的盒子。（图0-0-1(e)(f)(g)(h)）。

图0-0-1

(5)

?≠+?--=+=0

9mod 9/)0,0,0,0))},9mod (436(,0(max{09mod 9/)0,0,0,0,0,()

0,0,0,0,,(222122121a a a a f a a a f a a f

放完2?2的盒子后，多余的空间放1?1的盒子（图0-0-1(i)）。

(6)??36/)0,0,0,0,0,(11a a f =

显然，如果只有1?1的盒子，?a 1/36? 足够了（图0-0-1(j)）。

图0-0-1

按照(1), (2), (3), (4), (5), (6)的顺序的计算过程正是先考虑6?6的盒子，再考虑5?5的盒子，……，最后考虑1?1的盒子的贪心思想，所以以这6个等式的顺序设计出的算法可以求得最优解。

解

下面为算法描述。