NOIP2005普及组试题分析

试题分析

第一题，桃桃摘苹果。个人认为不应该花时间讲这道题，而主要强调题中的细节部分，不如碰到即为摘到苹果这样的情况，这里的细心决定了这到题的成败。再强调一下文件读取的基本操作。特别是对文件读写后的关闭操作。以及在这种文件读写题中，最后要将文件调试过程中的对屏幕输出和用readln;进行等待等语句去掉，否则因为这些问题影响成绩太不值得。

 

准备，让学生做一下提高组第一题，难度不大，但是细心程度要有所增加。

如下：

【问题描述】

某校的惯例是在每学期的期末考试之后发放奖学金。发放的奖学金共有五种，获取的条件各自不同：

1)院士奖学金，每人8000元，期末平均成绩高于80分（>80），并且在本学期内发表1篇或1篇以上论文的学生均可获得；

2)五四奖学金，每人4000元，期末平均成绩高于85分（>85），并且班级评议成绩高于80分（>80）的学生均可获得；

3)成绩优秀奖，每人2000元，期末平均成绩高于90分（>90）的学生均可获得；

4)西部奖学金，每人1000元，期末平均成绩高于85分（>85）的西部省份学生均可获得；

5)班级贡献奖，每人850元，班级评议成绩高于80分（>80）的学生干部均可获得；

    只要符合条件就可以得奖，每项奖学金的获奖人数没有限制，每名学生也可以同时获得多项奖学金。例如姚林的期末平均成绩是87分，班级评议成绩82分，同时他还是一位学生干部，那么他可以同时获得五四奖学金和班级贡献奖，奖金总数是4850元。

现在给出若干学生的相关数据，请计算哪些同学获得的奖金总数最高（假设总有同学能满足获得奖学金的条件）。

【输入文件】

    输入文件scholar.in的第一行是一个整数N（1 <= N <= 100），表示学生的总数。接下来的N行每行是一位学生的数据，从左向右依次是姓名，期末平均成绩，班级评议成绩，是否是学生干部，是否是西部省份学生，以及发表的论文数。姓名是由大小写英文字母组成的长度不超过20的字符串（不含空格）；期末平均成绩和班级评议成绩都是0到100之间的整数（包括0和100）；是否是学生干部和是否是西部省份学生分别用一个字符表示，Y表示是，N表示不是；发表的论文数是0到10的整数（包括0和10）。每两个相邻数据项之间用一个空格分隔。

【输出文件】

    输出文件scholar.out包括三行，第一行是获得最多奖金的学生的姓名，第二行是这名学生获得的奖金总数。如果有两位或两位以上的学生获得的奖金最多，输出他们之中在输入文件中出现最早的学生的姓名。第三行是这N个学生获得的奖学金的总数。

【样例输入】

4

YaoLin 87 82 Y N 0

ChenRuiyi 88 78 N Y 1

LiXin 92 88 N N 0

ZhangQin 83 87 Y N 1

【样例输出】

ChenRuiyi

9000

28700

 

第二题，校园外的树。题目设计的重复区域问题，只是希望能够避开，用计算每个区域内的树，然后总和得到总数目的情况。当然按照测试数据的情况，统计总数这种方法，也可以拿到20分。但是对于这样简单的题一定要拿到满分。经过分析数据的规模，我们可以考虑到规模并不是很大，那么我们就可以用统计法来做这道题，这样重复区域就对实际解题没有任何影响了。简单的定义一个一维数组用来做标记，然后再统计就可以满足题目要求。

 

program tree;

uses crt;

var

  fi,fo:text;

  long,m,total:word;

  a,b:array[1..100] of word;

  i,jian:integer;

  all:array[0..10000] of 0..1;

begin

  clrscr;

  total:=0;

  for i:=0 to 10000 do

    all[i]:=1;

  assign(fi,'tree.in');

  reset(fi);

  read(fi,long);

  read(fi,m);

  readln(fi);

  for i:=1 to m do

  begin

    read(fi,a[i]);

    read(fi,b[i]);

    readln(fi);

  end;

  for i:=1 to m do

  begin

    for jian:=a[i] to b[i] do

    begin

      all[jian]:=0;

    end;

  end;

  for i:=0 to long do

  begin

    if all[i]=1 then

      inc(total);

  end;

  assign(fo,'tree.out');

  rewrite(fo);

  writeln(fo,total);

  close(fi);

  close(fo);

end.

 

第三题，采药。这道题还是有难度的。基本解决思路有几种，贪心，模拟和动态规划。贪心算法能够解决举例的数据，但是测试数据则无法通过。模拟算法，可以通过30%的数据，即数据小与10个一下的测试数据。而对于100%的测试数据则严重超时无法计算。动态规划算法，解决较快，而且有效。

 

 

给出几种算法的大概思路，引导学生用三种算法完成这道题，体会算法的不同。

（1）贪心

program medic(input,output);

var f1,f2:text;

  med_t:array[1..100] of integer;

  med_v:array[1..100] of integer;

  med:array[1..100] of real;

  i,j,k,time,z,vale:integer;

  zz:real;

begin

assign(f1,'medic.in');

assign(f2,'medic.out');

reset(f1);

rewrite(f2);

read(f1,time,j);

for i:=1 to j do

begin

  read(f1,med_t[i],med_v[i]);

  med[i]:=med_v[i]/med_t[i];

  end;

for i:=1 to j-1 do{排序}

  for k:=i+1 to j do

  if med[i]

                    med_t[i]:=med_t[k];

                    med_t[k]:=z;

                    z:=med_v[i];

                    med_v[i]:=med_v[k];

                    med_v[k]:=z;

                    zz:=med[i];

                    med[i]:=med[k];

                    med[k]:=zz;

                  end;

  vale:=0;

  for i:=1 to j do

  begin

  if med_t[i]<=time then begin

                  vale:=vale+med_v[i];

                  time:=time-med_t[i];

                  end;

  if time=0 then break;

  end;

  write(f2,vale);

  close(f1);

  close(f2);

  end.

上面是一个用贪心算法完成的习题。但是，我们很容易找到贪心算法的反例，而且贪心算法是只能在局部最优的基础上，找出整体次优的解法。所以它很难适合现代竞赛的要求，但是是否贪心算法就毫无用处呢？其实不然，在现实生活中，因为贪心算法是最接近人们思维方式的算法，所以在设计很多方面的问题（特别是经济方面的问题时，有很大的应用）。下面我们阐述一下有关贪心算法的一个重要应用——找零钱问题。

引入到硬币题中，我们可以为国家货币发行机关制定这样的假设：每次找零要求硬币数最小。

那么由此产生下面这些想法：

1，首先究竟贪心法的正确率怎么样？

事实和理论都已经证明，贪心法是一种渐近最优解，它未必是最优的解。事实确实是这样，考虑下面一种硬币面值组合1、3、4，当需要找零6的时候，贪心算法会按照4、1、1的方案，而事实上，3、3的方案才是最优解。那么我们马上会想到，是不是最优解会在最大面值和第二面值两者之一产生呢？

事实也证明这也只是猜想，考虑1、8、9、11这四种面值的硬币，要找零24的时候，首先产生解11、11、1、1，然后是解9、9、1、1、1、1、1、1，而实际上8、8、8才是最优解。

于是我们可以知道，这种机制是没有办法产生确定的最优解的。

 

2，接下来的问题是：要满足怎么样条件的面值组合，才能够在所有情况下能用贪心法来求解呢？

首先考虑我们实际存在的硬币组合1、2、5，几乎所有的情况下，它都不会造成误解，

1=1

2=2

3=1+2

4=2+2

5=5

6=1+5

7=2+5

8=1+2+5

9=2+2+5

那我们再来考虑1、2、4这个组合

1=1

2=2

3=1+2

4=4

5=1+4

6=2+4

7=1+2+4

8=4+4

9=4+4+1

我们可以发现，为了表现1-9这9种金额，1、2、4和1、2、5的平均找零硬币个数是相等的。

如果我们在1、2、4中再添加一个8（这是很容易让人联想到的），会不会有什么新奇的结果呢？

事实上，如果我们没有10元钞票的话，添加一个8元的钞票确实能够减少平均找零硬币个数，但不幸的是，我们使用十进制，所以加入一个8元的面值硬币对我们并没有什么太大的显著改进。但是不可否认，从这一点上我们可以发现一些规律。

 

3，考虑完上述数学逻辑上的问题以后，我们把目光再放回到实际的问题上，我们已经制定了1、2、5的组合策略，现在让我们来想一想，为什么这个策略被选中了呢？

那是因为（正如上文已经说过的）我们使用的十进制，因此在124与125这类的面值都能够很好的满足贪心算法的前提下，我们当然会更愿意选择125这种方案，因为i10=5*2，更加让人心里觉得舒服。

 

因此，我们可以把硬币面值制定策略所要遵循的规则总结为：必须满足贪心算法（因为大多数人可以使用这种比较少费脑子的方法进行计算），必须在心理上尽量满足人们对于十进制运算的方便性考虑（这也是125方案被选中的原因）

 

(2)模拟

 

program medic_moni;

uses crt;

var

  fi,fo:text;

  i,j,k,b:integer;

  a:array[1..105] of 0..1;

  tt,vv:array[1..100] of integer;

  t,m:integer;

  total1:integer;

  value,max,time:longint;

begin

  clrscr;

  value:=0;max:=0;

  assign(fi,'medic.in');

  reset(fi);

  assign(fo,'medic.out');

  rewrite(fo);

  read(fi,t);

  read(fi,m);

  readln(fi);

  for i:=1 to m do

  begin

    read(fi,tt[i]);

    read(fi,vv[i]);

    readln(fi);

  end;

  for i:=1 to m do

    a[i]:=0;

  repeat

    k:=m;

    while (a[k]=1) do

    begin

      a[k]:=0;

      dec(k);

    end;

    a[k]:=1;

    time:=0;

    value:=0;

    for j:=1 to m do

    begin

       time:=time+tt[j]*a[j];

       value:=value+vv[j]*a[j]

    end;

    if (time<=t) and (value>max) then

      max:=value;

    total1:=0;

    for i:=1 to m do

      if a[i]=1 then

        inc(total1);

  until total1=m;

  writeln(fo,max);

  close(fi);

  close(fo);

end.

 

（3）动态规划

program medic;

uses crt;

var

  fi,fo:text;

  tt,vv:array[0..200] of integer;

  dp:array[0..1005,0..105] of integer;

  t,m:integer;

  i,j:integer;

  a,b:integer;

begin

  clrscr;

  assign(fi,'medic.in');

  reset(fi);

  assign(fo,'medic.out');

  rewrite(fo);

  read(fi,t);

  read(fi,m);

  readln(fi);

  for i:=1 to m do

  begin

    read(fi,tt[i]);

    read(fi,vv[i]);

    readln(fi);

  end;

  for i:=1 to t do

  begin

    for j:=1 to m do

    begin

      a:=dp[i][j-1];

      if i>=tt[j] then

      begin

        b:=dp[i-tt[j]][j-1]+vv[j];

        if b>a then

          a:=b;

      end;

      dp[i][j]:=a;

    end;

  end;

  writeln(fo,dp[t][m]);

  close(fi);

  close(fo);

end.

 

第四题，主要是应用高精度算法，加上一些优化算法，程序如下：

Program Circle;

Type

  Arr=Array[1..101] Of Integer;

Var

  i,j,p,k,code,L,num,tp:Integer;

  s: String;

  a,aa,time,b,temp:Arr;

//高精度乘法

Procedure Mutiply(a, b:Arr;Var c:Arr;t:Integer);

Var

  i, j: Integer;

Begin

  FillChar(c, SizeOf(c), 0);

  For i:=1 To t Do

    For j:=1 To t-i+1 Do

    Begin

      c[i+j-1]:=a[i]*b[j]+c[i+j-1];

      c[i+j]:=c[i+j]+c[i+j-1] Div 10;

      c[i+j-1]:=c[i+j-1] Mod 10;

    End;

End;

//高精度乘法，计算总次数，L表示次数的长度

Procedure Mutiply(a:Arr;b:Integer;Var c:Arr;Var L:Integer);

Var

  i: Integer;

Begin

  FillChar(c,SizeOf(c),0);

  For i:=1 To L Do

  Begin

//这里是乘，因为如果个位需要5次，十位需要5次，那么肯定需要25次才可以满足个位和十位的要求

c[i]:=c[i]+a[i]*b;

    c[i+1]:=c[i] Div 10;

    c[i]:=c[i] Mod 10;

  End;

  If c[L+1]<>0 Then

    Inc(L);

End;

 

Begin

  //重定位标准输入和标准输出设备

  Assign(Input, 'circle.in');

  Assign(Output, 'circle.out');

  ReSet(Input);

  ReWrite(Output);

 

  ReadLn(s);

  //分两部分截取s，和循环位数K

  Val(Copy(s, Pos(' ', s)+1, Length(s)-Pos(' ', s)), k, code);

  Delete(s, Pos(' ', s), Length(s)-Pos(' ', s)+1);

//将S倒转转化为数值存在数值类型的数组中以便于计算

  For i:=1 To Length(s) Do

    Val(s[i], a[Length(s)-i+1], code);

  aa:=a;

//初始化次数数组

  FillChar(time, SizeOf(time), 0);

  time[1] := 1;

  L := 1;

//开始计算

  For i:=1 To k Do

  Begin

    //从一位开始对比，直到K位，b为比较的初始数组

    For j:=1 To i Do

      b[j] := aa[j];

    tp := b[i];//TP为比较的位的值

    num := 0;

    Repeat

      Mutiply(b, a, b, i);

      Inc(num);

    Until (num > 10) Or (b[i] = tp);

//超过10次则代表就是无法满足循环条件了，因为只有10个数0..9

    If (b[i] <> tp) Then Begin

      Write(-1);

      Close(Input);

      Close(Output);

      Halt(0);

    End;

//根据需要几次才能满足，变化基础的乘因子a

    temp := a;

    For j:=1 To num-1 Do

      Mutiply(a, temp, a, k);

 

    Mutiply(time, num, time, L);

  End;

//反输出time，表示最终需要次数

  For i:=L DownTo 1 Do Write(time[i]);

 

  Close(Input);

  Close(Output);

End.

以上就是对第四题的解释。其中应用了几个巧妙的方法提高了运算的效率，如其中最突出的是基础因子法的使用以及计算总次数时的高精度乘法使用。

 

 

 

习题：

1、用贪心算法完成找零问题。由键盘输入找零的总数，在屏幕上输出需要找硬币的数目。

 

2、背包问题：给定N个物体和一个背包，已知物体I的重量为Wi>0，背包能容纳物体为M。要求确定一组分数Xi(0≤Xi≤1),把物体I的Xi部分放入背包，使得∑PiXi最大(Pi>0也是已知的，是物体i的总价格)，即将尽量多的价值装入背包。由于背包容许的重量为M，所以限制了装入的物体总重，为了得到尽量大的价值，装入背包的总重量应尽量接近M。我们要在0和1之间找到分数Xi，使集合（X1,x2,…,Xn）是可行解，即满足ΣWiXi≤M且使∑PiXi最大。

 

3、数的计数 要求用动态规划方法写出程序

[问题描述]

我们要求找出具有下列性质数的个数（包含输入的自然数N）：

先输入一个自然数N（N≦1000），然后对此自然数按照如下方法进行处理：

      1. 不做任何处理；

2. 再它的左边加上一个自然数，但该自然数不能超过原数的一半；

3.       加上数后，继续按此规则进行处理，直到不能再加自然数为止。

[样例]：输入6

满足条件的数为  6  （此部分不必输出）

16

26

126

 36

136

输出： 6

 

4、园林工人借助于高科技装置，可以把一棵树上的害虫全部消灭，但是付出的代价是吓跑相邻树上的所有害虫。现在只有一台高科技装置，要消灭公路左侧一行共n棵树上的害虫，最多能消灭多少害虫？请把结果打印在屏幕上。N棵树上的害虫数由输入文件给出。每棵树上的害虫数都不超过10000，文件共有两行，第一行是n，第二行依次为各树上的害虫数。

[样例]输入文件：

5

15 0 0 99 88

输出文件：

114

 

5、过河

【问题描述】

在河上有一座独木桥，一只青蛙想沿着独木桥从河的一侧跳到另一侧。在桥上有一些石子，青蛙很讨厌踩在这些石子上。由于桥的长度和青蛙一次跳过的距离都是正整数，我们可以把独木桥上青蛙可能到达的点看成数轴上的一串整点：0，1，……，L（其中L是桥的长度）。坐标为0的点表示桥的起点，坐标为L的点表示桥的终点。青蛙从桥的起点开始，不停的向终点方向跳跃。一次跳跃的距离是S到T之间的任意正整数（包括S,T）。当青蛙跳到或跳过坐标为L的点时，就算青蛙已经跳出了独木桥。

题目给出独木桥的长度L，青蛙跳跃的距离范围S,T，桥上石子的位置。你的任务是确定青蛙要想过河，最少需要踩到的石子数。

 

【输入文件】

输入文件river.in的第一行有一个正整数L（1 <= L <= 109），表示独木桥的长度。第二行有三个正整数S，T，M，分别表示青蛙一次跳跃的最小距离，最大距离，及桥上石子的个数，其中1 <= S <= T <= 10，1 <= M <= 100。第三行有M个不同的正整数分别表示这M个石子在数轴上的位置（数据保证桥的起点和终点处没有石子）。所有相邻的整数之间用一个空格隔开。

【输出文件】

输出文件river.out只包括一个整数，表示青蛙过河最少需要踩到的石子数。

【样例输入】

10

2 3 5

2 3 5 6 7

【样例输出】

2

【数据规模】

对于30%的数据，L <= 10000；

对于全部的数据，L <= 109。