NOIP普及组，试题分析教案准备

冬令营课程安排提纲

 

第一天、试题分析安排

第一题，桃桃摘苹果。个人认为不应该花时间讲这道题，而主要强调题中的细节部分，不如碰到即为摘到苹果这样的情况，这里的细心决定了这到题的成败。再强调一下文件读取的基本操作。特别是对文件读写后的关闭操作。以及在这种文件读写题中，最后要将文件调试过程中的对屏幕输出和用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[k] then begin z:=med_t[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;

 

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

    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);

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

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

 

  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

    For j:=1 To i Do

      b[j] := aa[j];

    tp := b[i];

    num := 0;

    Repeat

      Mutiply(b, a, b, i);

      Inc(num);

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

 

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

      Write(-1);

      Close(Input);

      Close(Output);

      Halt(0);

    End;

 

    temp := a;

    For j:=1 To num-1 Do

      Mutiply(a, temp, a, k);

 

    Mutiply(time, num, time, L);

  End;

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

 

  Close(Input);

  Close(Output);

End.

 

经测试这个程序完全满足题目要求。但是有一些地方还是很需要更改的。