几道记忆化搜索专题(ackerman 滑雪 恶魔城)

1、ackerman函数

( ackerman.pas/cpp/c )

问题描述：

计算ackerman函数值:

输入格式：

从文件ackerman.in读入数据，第一行为两个数，即M和N，其中0<=M<=3，0<=N<=11。

 

输出格式：

向文件ackerman.out输出ack(m,n)的值。

 

样例1：

ackerman.in	ackerman.out
0 1	2

 

说明：有极限数据，用朴素递归算法只得36分

提示：ackerman函数的增长是很惊人的，在我们想象得到的函数值中,m远小于10

用f[I,j]保存函数值时，j可能很大。

在分析并查集的算法复杂度时曾提到：采用路径压缩后,每一次查询所用的时间复杂度为增长极为缓慢的ackerman函数的反函数——α(x)。对于可以想象到的n,α(n)都是在5之内的。

代码写得有点繁琐。。

var
  y,x,ans:longint;
  a:array[0..3,0..100000] of longint;
procedure init;
begin
   assign(input,'ackerman.in');
   assign(output,'ackerman.out');
   reset(input);
   rewrite(output);
end;
procedure ack(m,n:longint);
begin
  if m=0 then
  begin
    a[m,n]:=n+1;
    exit;
  end;
  if n=0 then
  begin
    if a[m-1,1]<>0 then a[m,n]:=a[m-1,1]
    else
    begin
      ack(m-1,1);
      a[m,n]:=a[m-1,1];
    end;
    exit;
  end;
  if a[m,n-1]<>0 then
  begin
    if a[m-1,a[m,n-1]]<>0 then a[m,n]:=a[m-1,a[m,n-1]]
    else
    begin
      ack(m-1,a[m,n-1]);
      a[m,n]:=a[m-1,a[m,n-1]];
    end;
  end else
  begin
    ack(m,n-1);
    ack(m-1,a[m,n-1]);
    a[m,n]:=a[m-1,a[m,n-1]];
  end;
end;
procedure main;
begin
  fillchar(a,sizeof(a),0);
  readln(x,y);
  ack(x,y);
  ans:=a[x,y];
  writeln(ans);
end;
procedure outit;
begin
  close(input);
  close(output);
end;
begin
  init;
  main;
  outit;
end.

2、滑雪

(sequence.pas/c/cpp)

 

【问题描述】

滑雪是一项非常刺激的运动，为了获得速度，滑雪的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。给出一个由二维数组表示的滑雪区域，数组的数字代表各点的高度。请你找出这个区域中最长的滑坡。

下面是一个例子：

1  2  3  4  5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然，25-24-23-...-3-2-1更长。事实上，这是最长的一条滑坡。

 

【输入文件】

 

输入文件ski.in的第一行为两个数R, C，表示滑雪区域的行数和列数（1≤R,C≤100）。下面是R行，每行有C个整数，表示高度H（0≤H≤10000）。

 

【输出文件】

 

输出文件ski.out包括一行，只包含一个整数，表示滑雪区域中最长滑坡的长度。

 

【样例输入】

 

5 5

1 2 3 4 5

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

 

【样例输出】

 

25

这是一道典型的记忆化，思想很像LCS

const
  maxn=100;
  gox:array[1..4]of integer=(0,1,-1,0);
  goy:array[1..4]of integer=(1,0,0,-1);
var
  map,f:array[0..maxn+1,0..maxn+1] of longint;
  h:array[0..maxn+1,0..maxn+1] of boolean;
  r,c,max:longint;
procedure init;
begin
  assign(input,'ski.in');
  assign(output,'ski.out');
  reset(input);
  rewrite(output);
end;
function find(x,y:longint):longint;
var
  i:longint;
begin
  if h[x,y] then exit(f[x,y]);
  for i:=1 to 4 do
  begin
    if (map[x+gox[i],y+goy[i]]<>-1) and (map[x+gox[i],y+goy[i]]<map[x,y]) then
    begin
      if find(x+gox[i],y+goy[i])+1>f[x,y] then f[x,y]:=f[x+gox[i],y+goy[i]]+1;
    end;
  end;
  h[x,y]:=true;
  exit(f[x,y]);
end;
procedure main;
var
  i,j:longint;
begin
  readln(r,c);
  fillchar(map,sizeof(map),$ff);
  fillchar(f,sizeof(f),0);
  fillchar(h,sizeof(h),0);
  max:=0;
  for i:=1 to r do
    for j:=1 to c do
      read(map[i,j]);
  for i:=1 to r do
    for j:=1 to c do
    begin
      if find(i,j)>max then max:=f[i,j];
    end;
  writeln(max+1);
end;
procedure outit;
begin
  close(input);
  close(output);
end;
begin
  init;
  main;
  outit;
end.

 

再附上递推代码

program ski;
const finp='ski.in';
      fout='ski.out';
      p:array[1..4,1..2] of integer=
      ((1,0),(0,1),(-1,0),(0,-1));
type rec=record
           r,c,h:integer;
         end;
var h,f:array[1..100,1..100] of integer;
    a:array[1..10000] of rec;
    r,c,max:longint;
procedure init;
var i,j:longint;
begin
  assign(input,finp);
  reset(input);
  readln(r,c);
  for i:=1 to r do
    for j:=1 to c do
      begin
        read(h[i,j]);
        a[(i-1)*c+j].r:=i;
        a[(i-1)*c+j].c:=j;
        a[(i-1)*c+j].h:=h[i,j];
        if j=c then readln;
      end;
  close(input);
end;

procedure qsort(l,r:longint);
var i,j,x:longint;
    tmp:rec;
begin
  i:=l; j:=r; x:=a[(l+r) div 2].h;
  repeat
    while a[i].h<x do inc(i);
    while x<a[j].h do dec(j);
    if i<=j
       then begin
              tmp:=a[i]; a[i]:=a[j]; a[j]:=tmp;
              inc(i); dec(j);
            end;
  until i>j;
  if i<r then qsort(i,r);
  if l<j then qsort(l,j);
end;

procedure main;
var i,j,x,y:longint;
begin
  qsort(1,r*c);
  fillchar(f,sizeof(f),0);
  for i:=1 to r*c do
    for j:=1 to 4 do
      begin
        x:=a[i].r+p[j,1];
        y:=a[i].c+p[j,2];
        if (x>0) and (x<=r) and (y>0) and (y<=c)
           then if h[x,y]<h[a[i].r,a[i].c]
                   then if f[x,y]+1>f[a[i].r,a[i].c]
                           then f[a[i].r,a[i].c]:=f[x,y]+1;
      end;
  max:=0;
  for i:=1 to r do
    for j:=1 to c do
      if f[i,j]>max
         then max:=f[i,j];
  assign(output,fout);
  rewrite(output);
  writeln(max+1);
  close(output);
end;

begin
  init;
  main;
end.

 

3:　恶魔城（Satanic Castle）

（santanic.pas/cpp/c）

问题描述：

上帝需要创造一位战士去消灭撒旦，这位战士必须要穿过恶魔城才能与撒旦决斗。恶魔城内有M条连接N个路口（从1到N编号）的街道，每一条街道都是单向的（也就是说你不能逆着该街道指定的方向走），并且在城内无论怎么走都不可能走回原来走过的地方。开始的时候，战士的生命力（HP）为INITHP、站在１号路口，而撒旦在第N号路口等待着他。每一条街道上都有许多魔鬼，但是也有一些街道已经被上帝派去的天使占领了。当战士经过连接i号向j号路口的街道时，如果占领该街道的是恶魔，那么他的HP先加倍然后减少L[i,j]，我们记为A[i,j]=-L[i,j]；如果占领该街道的是天使，那么他的HP就会先加倍然后增加L[i,j]，我们记为A[i,j]=+L[i,j]；如果该街道不存在，那么A[i,j]=0。如果某一时刻战士的HP<=0，那么他会死亡。因为这个战士将非常无敌，当他见到撒旦的时候只要还活着，就能一口气把撒旦消灭，所以上帝不希望让他的INITHP过高。

 

任务：

给定N，A[1..N,1..N]，求最小的INITHP，使这个战士能够活着见到撒旦。

 

输入格式：

从文件SATANIC.DAT读入数据，文件第一行有一个正整数N（3 ≤ N ≤ 100），下面跟着的第i行第j个数为A[i,j]（绝对值不超过10000的整数）。

 

输出格式：

输出所求最小的INITHP。

 

样例

SATANIC.DAT	SATANIC.OUT
4 0 -4 0 –10 0 0 +3 0 0 0 0 –14 0 0 0 0	4

这种写法是非递归的：

const
  maxn=100;
var
  n:longint;
  a:array[1..maxn,1..maxn] of longint;
  f:array[1..maxn] of longint;
procedure init;
begin
  assign(input,'satanic.in');
  assign(output,'satanic.out');
  reset(input);
  rewrite(output);
end;
procedure main;
var
  i,j,tmp:longint;
  flag:boolean;
begin
  readln(n);
  for i:=1 to n do
    for j:=1 to n do
      read(a[i,j]);
  flag:=true;
  fillchar(f,sizeof(f),0);
  f[n]:=1;
  while flag do
  begin
    flag:=false;
    for i:=1 to n do
      if f[i]>0 then
      for j:=1 to n do
        if (i<>j) and (a[j,i]<>0) then
        begin
          tmp:=(f[i]-a[j,i]+1) div 2;
          if tmp<=0 then tmp:=1;
          if (f[j]=0) or (f[j]>tmp) then
          begin
            f[j]:=tmp;
            flag:=true;
          end;
        end;
  end;
  writeln(f[1]);
end;
procedure outit;
begin
  close(input);
  close(output);
end;
begin
  init;
  main;
  outit;
end.