2017完整普及组题解Pascal

1.成绩(score.cpp/c/pas)

【问题描述】

牛牛最近学习了 C++入门课程，这门课程的总成绩计算方法是:

总成绩=作业成绩×20%+小测成绩×30%+期末考试成绩×50%

牛牛想知道，这门课程自己最终能得到多少分。

【输入格式】

输入文件名为 score.in。

输入文件只有 1 行，包含三个非负整数A、B、C，分别表示牛牛的作业成绩、小测成绩和期末考试成绩。相邻两个数之间用一个空格隔开，三项成绩满分都是 100 分。

【输出格式】

输出文件名为 score.out。

输出文件只有 1 行，包含一个整数，即牛牛这门课程的总成绩，满分也是 100 分。

【输入输出样例 1】

score.in

100100 80

score.out

90

【输入输出样例 2】

score.in

60 90 80

score.out

79

【数据说明】

对于 30% 的数据，A=B=0。 

对于另外 30% 的数据，A = B = 100。

对于 100% 的数据， 0 ≤ A、B、C ≤ 100 且 A、B、C 都是 10 的整数倍。

题解：垃圾题目，自己去解

 

var

  n,m,i,j,a,b,c:longint;

begin

  readln(a,b,c);

  m:=a*20 div 100+b*30 div 100+c*50 div 100;

  writeln(m);

end.

 

2. 图书管理员 (librarian.cpp/c/pas)

【问题描述】 

图书馆中每本书都有一个图书编码，可以用于快速检索图书，这个图书编码是一个正整数。 

每位借书的读者手中有一个需求码，这个需求码也是一个正整数。如果一本书的图书编码恰好以读者的需求码结尾，那么这本书就是这位读者所需要的。

小 D 刚刚当上图书馆的管理员，她知道图书馆里所有书的图书编码，她请你帮她写一个程序，对于每一位读者，求出他所需要的书中图书编码最小的那本书，如果没有他需要的书，请输出-1。

【输入格式】

输入文件名为 librarian.in。

输入文件的第一行，包含两个正整数 n 和 q，以一个空格分开，分别代表图书馆里书的数量和读者的数量。

接下来的 n 行，每行包含一个正整数，代表图书馆里某本书的图书编码。 

接下来的 q 行，每行包含两个正整数，以一个空格分开，第一个正整数代表图书馆里读者的需求码的长度，第二个正整数代表读者的需求码。

【输出格式】

输出文件名为 librarian.out。

输出文件有 q 行，每行包含一个整数，如果存在第 i 个读者所需要的书，则在第 i行输出第 i 个读者所需要的书中图书编码最小的那本书的图书编码，否则输出-1。 

【输入输出样例 1】

librarian.in

5  5

2123

1123

23

24

24

2  23

3  123

3  124

2  12

2  12

librarian.out

23

1123

-1

-1

-1

【数据规模与约定】

对于 20%的数据，1 ≤ n ≤ 2。

另有 20%的数据，q = 1。

另有 20%的数据，所有读者的需求码的长度均为 1。

另有 20%的数据，所有的图书编码按从小到大的顺序给出。

对于 100%的数据，1 ≤ n ≤ 1,000，1 ≤ q ≤ 1,000，所有的图书编码和需求码均不超过 10,000,000。

题解：代码能力的模拟测试题，咋搞都爆不了（pos要找代码也行，不用字符串也行）

注意：图书编码 mod 10^编码长度与需求码比较，我们可以定义变量min来存储最小编码！

代码：

var

  n,m,i,j,x,y,k,v:longint;

  a,b:array[1..100000] of string;

  t,f:boolean;

  min:longint;

begin

  readln(n,m);

  for i:=1 to n do

    readln(a[i]);

  for i:=1 to m do

  begin

    readln(x,y);

    str(y,b[i]);

  end;

  for i:=1 to m do

  begin

    min:=100000000;

    for j:=1 to n do

    begin

      if length(b[i])>length(a[j])  then

        continue;

      for k:=1 to length(b[i]) do

        if b[i,k]<>a[j,length(a[j])-length(b[i])+k] then

        begin

          t:=true;

          break;

        end;

      val(a[j],v,y);

      if (not t) and (v<min) then

      begin

        min:=v;

        f:=true;

      end;

      t:=false;

    end;

    if not f then

      writeln(-1) else

    writeln(min);

    f:=false;

  end;

end.

3. 棋盘 (chess.cpp/c/pas)

【问题描述】

有一个m × m的棋盘，棋盘上每一个格子可能是红色、黄色或没有任何颜色的。你现在要从棋盘的最左上角走到棋盘的最右下角。 

任何一个时刻，你所站在的位置必须是有颜色的(不能是无色的)，你只能向上、下、左、右四个方向前进。当你从一个格子走向另一个格子时，如果两个格子的颜色相同，那你不需要花费金币;如果不同，则你需要花费 1 个金币。

另外，你可以花费 2 个金币施展魔法让下一个无色格子暂时变为你指定的颜色。但这个魔法不能连续使用，而且这个魔法的持续时间很短，也就是说，如果你使用了这个魔法，走到了这个暂时有颜色的格子上，你就不能继续使用魔法;只有当你离开这个位置，走到一个本来就有颜色的格子上的时候，你才能继续使用这个魔法，而当你离开了这个位置(施展魔法使得变为有颜色的格子)时，这个格子恢复为无色。

现在你要从棋盘的最左上角，走到棋盘的最右下角，求花费的最少金币是多少?

【输入格式】

输入文件名为 chess.in。

数据的第一行包含两个正整数 m，n，以一个空格分开，分别代表棋盘的大小，棋盘上有颜色的格子的数量。

接下来的 n 行，每行三个正整数 x，y，c，分别表示坐标为(x，y)的格子有颜色 c。其中 c=1 代表黄色，c=0 代表红色。相邻两个数之间用一个空格隔开。棋盘左上角的坐标为(1, 1)，右下角的坐标为(m, m)。

棋盘上其余的格子都是无色。保证棋盘的左上角，也就是(1，1)一定是有颜色的。

【输出格式】

输出文件名为 chess.out。 

输出一行，一个整数，表示花费的金币的最小值，如果无法到达，输出-1。

【输入输出样例 1】

chess.in

5 7

1  1  0

1  2  0

2  2  1

3  3  1

3  4  0

4  4  1

5  5  0

chess.out

8

【输入输出样例 2】

chess.in

5  5

1  1  0

1  2  0

2  2  1

3  3  1

5  5  0

chess.out

-1

【数据规模与约定】

对于 30%的数据，1 ≤ m ≤ 5， 1 ≤ n ≤ 10。

对于 60%的数据，1 ≤ m ≤ 20， 1 ≤ n ≤ 200。 

对于100%的数据，1 ≤ m ≤ 100， 1 ≤ n ≤ 1,000。

题解：记忆化的最佳锻炼时期，dfs虽然TLE但是，加一个记忆化可能会好一些，（1000*1000*100爆不了把）方法也是有很多的（DP坚决不行，方向天生不够。。。）

注意：魔法要把变的颜色和当前一样。 

代码：

var x,y,k,n,m,i,j:longint; a,f:array[0..1010,0..1010] of longint; procedure try(dq,x,y,ma:longint;cannot:boolean); var i,j:longint;begin if (x>n) or (x<1) or (y>n) or (y<1) then exit; f[x,y]:=dq; if (abs(ma-a[x+1,y])+dq<f[x+1,y]) and (a[x+1,y]<>-1) then try(abs(ma-a[x+1,y])+dq,x+1,y,a[x+1,y],false); if (abs(ma-a[x,y+1])+dq<f[x,y+1]) and (a[x,y+1]<>-1) then try(abs(ma-a[x,y+1])+dq,x,y+1,a[x,y+1],false); if (abs(ma-a[x-1,y])+dq<f[x-1,y]) and (a[x-1,y]<>-1) then try(abs(ma-a[x-1,y])+dq,x-1,y,a[x-1,y],false); if (abs(ma-a[x,y-1])+dq<f[x,y-1]) and (a[x,y-1]<>-1)then try(abs(ma-a[x,y-1])+dq,x,y-1,a[x,y-1],false);//这些很明确了，找条最优路径计算总分 if (not cannot)then begin if (2+dq<f[x+1,y]) and (a[x+1,y]=-1)then try(dq+2,x+1,y,ma,true); if (2+dq<f[x-1,y]) and (a[x-1,y]=-1) then try(dq+2,x-1,y,ma,true); if (2+dq<f[x,y+1]) and (a[x,y+1]=-1) then try(dq+2,x,y+1,ma,true); if (2+dq<f[x,y-1]) and (a[x,y-1]=-1) then try(dq+2,x,y-1,ma,true);//找到最优路径+魔法金币2个 end; end; begin for i:=0 to 1010 do for j:=0 to 1010 do a[i,j]:=-1; readln(n,m); for i:=1 to m do begin readln(x,y,k); a[x,y]:=k; end; for i:=0 to n+1 do for j:=0 to n+1 do f[i,j]:=988;try(0,1,1,a[1,1],false); if f[n,n]=988 then writeln(-1) else//如果无法通过 writeln(f[n,n]); end.

跳房子（jump.cpp/c/pas）

题目描述

跳房子，也叫跳飞机，是一种世界性的儿童游戏，也是中国民间传统的体育游戏之一。跳房子的游戏规则如下：

在地面上确定一个起点，然后在起点右侧画 n 个格子，这些格子都在同一条直线上。每个格子内有一个数字（整数），表示到达这个格子能得到的分数。玩家第一次从起点开始向右跳，跳到起点右侧的一个格子内。第二次再从当前位置继续向右跳，依此类推。规则规定：玩家每次都必须跳到当前位置右侧的一个格子内。玩家可以在任意时刻结束游戏，获得的分数为曾经到达过的格子中的数字之和。

现在小 R 研发了一款弹跳机器人来参加这个游戏。但是这个机器人有一个非常严重的缺陷，它每次向右弹跳的距离只能为固定的 d。小 R 希望改进他的机器人，如果他花 g 个金币改进他的机器人，那么他的机器人灵活性就能增加 g，但是需要注意的是，每次弹跳的距离至少为 1。具体而言，当g < d时，他的机器人每次可以选择向右弹跳的距离为 d-g, d-g+1, d-g+2，…，d+g-2，d+g-1，d+g；否则（当g ≥ d时），他的机器人每次可以选择向右弹跳的距离为 1，2，3，…，d+g-2，d+g-1，d+g。

现在小 R 希望获得至少 k 分，请问他至少要花多少金币来改造他的机器人。

输入

输入文件名为jump.in。

第一行三个正整数 n，d，k，分别表示格子的数目，改进前机器人弹跳的固定距离，以及希望至少获得的分数。相邻两个数之间用一个空格隔开。

接下来 n 行，每行两个正整数

输出

输出文件名为jump.out。

共一行，一个整数，表示至少要花多少金币来改造他的机器人。若无论如何他都无法获得至少 k 分，输出-1。

样例输入

7 4 10

2 6

5 -3

10 3

11 -3

13 1

17 6

20 2

 

样例输出

2

 

提示

【输入输出样例 1 说明】

 

 花费 2 个金币改进后，小 R 的机器人依次选择的向右弹跳的距离分别为 2，3，5，3，4， 3，先后到达的位置分别为2，5，10，13，17，20，对应 1, 2, 3, 5, 6, 7 这 6 个格子。这些格子中的数字之和 15 即为小 R 获得的分数。

 

 

 

【数据规模与约定】

 

 

本题共 10 组测试数据，每组数据 10 分。对于全部的数据满足1 ≤ n≤ 500000, 1 ≤ d ≤2000,1<=k<=1000

 

 

析：这道是普及组压轴的第四题，说真心话这是一道组合大水题，并不像我们想象的那么难。

我们把d-g, d-g+1, d-g+2，…，d+g-2，d+g-1，d+g看做成一个区间，f[i]就是伤害值，那不就等价于上一道题吗？？？

（于是这道题目的核心根本是定区间求最值+二分，二分枚举答案，用定区间求最小验证答案，就AC了。）

代码部分特别简单,把上一题的核心代码复制一遍+二分就行了。

伪代码STD：

User:

Procedure binarysearch(l,r:longint);

Function check(x:longint):boolean;

{//跳棋（详见我写的{跳棋、跳房子与单调队列}）代码稍作修改

If 最小值=x then

  Exit(true) else

Exit(false);

}

Main(){

  Binarysearch(1,n);

}

彩蛋：

跳房子std:

var
  a,x1:array[-500000..1000000] of longint;
  n,m,i,j,x,y,l,r,d,k,ans:longint;
  f,q:array[-1000..500000] of int64;
function check(x:longint):boolean;
var
  head,tail,l,r,i,xx:longint;
begin
  for i:=1 to n  do
  begin
    f[i]:=-100000808;
  end;
  f[0]:=0;
  q[1]:=0;
  head:=1;
  tail:=0;
  xx:=0;
  for i:=1 to n do
  begin
    while (x1[i]-x1[xx]>d+x) and (xx<=i) do inc(xx);
    while (xx<i) and (x1[i]-x1[xx]>=d-x) and (x1[i]-x1[xx]<=d+x) do
    begin
      while (f[xx]>f[q[tail]]) and (head<=tail) do dec(tail);
        inc(tail);
      q[tail]:=xx;
      inc(xx);
    end;
    while (x1[i]-x1[q[head]]>d+x) and (head<=tail) do inc(head);
    if (head<=tail) and (x1[i]-x1[q[head]]>=d-x) and (x1[i]-x1[q[head]]<=d+x) then f[i]:=f[q[head]]+a[i];
    if (f[i]>=k)  then
      exit(true);
    end;
  exit(false);


end;
begin
  readln(n,d,k);
  for i:=1 to n do
    readln(x1[i],a[i]);
  ans:=-1;
  l:=0;
  r:=x1[n];
  while (l<=r) do
  begin
    m:=(l+r) div 2;
    if check(m) then
    begin
      r:=m-1;
      ans:=m;
    end else
    l:=m+1;
  end;
  writeln(ans);
end.