2014-02 记忆化搜索练习

总结：注意初始化标记、边界条件
1、数的计数(count.pas)
[问题描述]

    我们要求找出具有下列性质数的个数(包含输入的自然数n):

    先输入一个自然数n(n≤1000)，然后对此自然数按照如下方法进行处理

    l·不作任何处理:

    z·茬它的左边加上一个自然数，但该自然数不能超过原数的一半;

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

[样例]    输入：6(count.in)

                满足条件的数为  6     (此部分不必输出)

6

16

                           26

                          126

                           36

                          136

          输出：6(count.out)

 #include<cstdio>

long f[1001];
long work(int num)
{

if (f[num]!=-1) return f[num];
f[num]=1;
for (int i=1;i<=num>>1;i++)
f[num]+=work(i);
return f[num];
}

int main()
{
freopen("count.in","r",stdin);
freopen("count.out","w",stdout);
int n;
scanf("%d",&n);
for (int i=1;i<=n;i++) f[i]=-1;
printf("%ld\n",work(n));
fclose(stdin);
fclose(stdout);
}

2、栈（Stack.pas）

【问题背景】栈是计算机中经典的数据结构，简单的说，栈就是限制在一端进行插入删除操作的线性表。

栈有两种最重要的操作，即pop（从栈顶弹出一个元素）和push（将一个元素进栈）。

栈的重要性不言自明，任何一门数据结构的课程都会介绍栈。宁宁同学在复习栈的基本概念时，想到了一个书上没有讲过的问题，而他自己无法给出答案，所以需要你的帮忙。

 

【问题描述】



宁宁考虑的是这样一个问题：一个操作数序列，从1，2，一直到n（图示为1到3的情况），栈A的深度大于n。

现在可以进行两种操作，

1.将一个数，从操作数序列的头端移到栈的头端（对应数据结构栈的push操作）

2. 将一个数，从栈的头端移到输出序列的尾端（对应数据结构栈的pop操作） 

使用这两种操作，由一个操作数序列就可以得到一系列的输出序列，下图所示为由1 2 3生成序列2 3 1的过程。（原始状态如上图所示）

你的程序将对给定的n，计算并输出由操作数序列1，2，…，n经过操作可能得到的输出序列的总数。

 

【输入格式】

输入文件只含一个整数n（1≤n≤19）

【输出格式】

输出文件只有一行，即可能输出序列的总数目

 

【输入样例】

3

 

【输出样例】

5

 #include<cstdio>
int n,f[20][20];

int work(int top,int r)//top 栈顶指针 r 入队序列指针
{
if (r>n) return f[top][r]=1;
if (f[top][r]!=-1) return f[top][r]; //这两句顺序不能调换
int tmp=0;
if (top) tmp+=work(top-1,r);
tmp+=work(top+1,r+1);
return f[top][r]=tmp;
}

int main()
{
freopen("stack.in","r",stdin);
freopen("stack.out","w",stdout);
scanf("%d",&n);
for (int i=0;i<=n;i++)
for (int j=0;j<=n;j++)
f[i][j]=-1;
printf("%d\n",work(0,1));
fclose(stdin); fclose(stdout);
}

3、核电站问题

Nuclear.pas
一个核电站有N个放核物质的坑，坑排列在一条直线上。如果连续M个坑中放入核物质，则会发生爆炸，于是，在某些坑中可能不放核物质。

　　任务：对于给定的N和M，求不发生爆炸的放置核物质的方案总数
输入：　　输入文件只一行，两个正整数N，M( 1<N<50，2≤M≤5)
输出：　　输出文件只有一个正整数S，表示方案总数。

Sample Input 4 3

Sample Output 13

【思路】有动规+组合数学 和 记忆化搜索两种做法

#include<cstdio>
using namespace std;
int n,m;
long long f[52][7];

long long work(int x,int k)
{
if (x>n) return f[x][k]=1; //目标状态，方案=1
if (f[x][k]!=-1) return f[x][k];
long long tmp=0; //long long
if (k+1<m) tmp+=work(x+1,k+1);
tmp+=work(x+1,0);
return f[x][k]=tmp;
}

int main()
{
freopen("nuclear.in","r",stdin);
freopen("nuclear.out","w",stdout);
scanf("%d%d",&n,&m);
for (int i=0;i<=n;i++)
for (int j=0;j<=m;j++) f[i][j]=-1;
printf("%I64d\n",work(1,0));
}

4、滑  雪（ SKI.pas ）

Michael喜欢滑雪。这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道在一个区域中最长的滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子：

                                           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-24-17-16-1(从25开始到1结束)。当然25－24－23―┅―3―2―1更长。事实上，这是最长的一条。

 

	[I-1,J]
[I,J-1]	[I,J]	[I,J+1]
	[I+1,J]

 

 

 

输入输出要求(ski.in)(ski.out)

输入的第一行为表示区域的二维数组的行数R和列数C（1≤R，C≤100）。下面是R行，每行有C个数，代表高度。

输出区域中最长滑坡的长度。

 

 

样例输入和相应输出

输入	输出 4000
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

 var r,c,i,j,ans:longint;
f,map:array[0..101,0..101]of longint;
procedure max(var a:longint; b:longint);
begin
if b>a then a:=b;
end;

function search(x,y:longint):longint;
var len:longint;
begin
len:=0;
if f[x,y]<>0 then exit(f[x,y]);
if (x-1>0)and(map[x-1,y]<map[x,y]) then max(len,search(x-1,y));
if (x+1<=r)and(map[x+1,y]<map[x,y])then max(len,search(x+1,y));
if (y-1>0)and(map[x,y-1]<map[x,y]) then max(len,search(x,y-1));
if (y+1<=c)and(map[x,y+1]<map[x,y])then max(len,search(x,y+1));
f[x,y]:=len+1;
exit(f[x,y]);
end;

begin
assign(input,'ski.in'); reset(input);
assign(output,'ski.out'); rewrite(output);
fillchar(f,sizeof(f),0);
readln(r,c);
ans:=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
max(ans,search(i,j));
writeln(ans);
close(input); close(output);
end.

5、能量项链
(energy.pas/c/cpp)
 
【问题描述】

在Mars星球上，每个Mars人都随身佩带着一串能量项链。在项链上有N颗能量珠。能量珠是一颗有头标记与尾标记的珠子，这些标记对应着某个正整数。并且，对于相邻的两颗珠子，前一颗珠子的尾标记一定等于后一颗珠子的头标记。因为只有这样，通过吸盘（吸盘是Mars人吸收能量的一种器官）的作用，这两颗珠子才能聚合成一颗珠子，同时释放出可以被吸盘吸收的能量。如果前一颗能量珠的头标记为m，尾标记为r，后一颗能量珠的头标记为r，尾标记为n，则聚合后释放的能量为（Mars单位），新产生的珠子的头标记为m，尾标记为n。

需要时，Mars人就用吸盘夹住相邻的两颗珠子，通过聚合得到能量，直到项链上只剩下一颗珠子为止。显然，不同的聚合顺序得到的总能量是不同的，请你设计一个聚合顺序，使一串项链释放出的总能量最大。

例如：设N=4，4颗珠子的头标记与尾标记依次为(2，3) (3，5) (5，10)(10，2)。我们用记号⊕表示两颗珠子的聚合操作，(j⊕k)表示第j，k两颗珠子聚合后所释放的能量。则第4、1两颗珠子聚合后释放的能量为：

(4⊕1)=10*2*3=60。

这一串项链可以得到最优值的一个聚合顺序所释放的总能量为

((4⊕1)⊕2)⊕3）=10*2*3+10*3*5+10*5*10=710。

 

【输入文件】

输入文件energy.in的第一行是一个正整数N（4≤N≤100），表示项链上珠子的个数。第二行是N个用空格隔开的正整数，所有的数均不超过1000。第i个数为第i颗珠子的头标记（1≤i≤N），当i<N时，第i颗珠子的尾标记应该等于第i+1颗珠子的头标记。第N颗珠子的尾标记应该等于第1颗珠子的头标记。

至于珠子的顺序，你可以这样确定：将项链放到桌面上，不要出现交叉，随意指定第一颗珠子，然后按顺时针方向确定其他珠子的顺序。

【输出文件】

输出文件energy.out只有一行，是一个正整数E（E≤2.1*109），为一个最优聚合顺序所释放的总能量。

【输入样例】

 4

 2  3  5  10

【输出样例】

710

 【思路】我用的区间动规，注意循环顺序

#include<cstdio>
#include<cstring>

long f[201][201],max;
int e[201];
int i,j,n;
int main()
{
freopen("energy.in","r",stdin);
freopen("energy.out","w",stdout);
scanf("%d",&n);
for (i=1;i<=n;i++)
{
scanf("%d",&e[i]);
e[i+n]=e[i];
}
memset(f,0,sizeof(f));
/*for (i=1;i<=n;i++)
for (j=1;j<=i+n-1;j++)
{
if (i==j) f[i][j]=0;
else if (i<j)
{
for (int k=i;k<j;k++)
if (f[i][k]+f[k+1][j]+e[i]*e[k+1]*e[j+1]>f[i][j])
f[i][j]=f[i][k]+f[k+1][j]+e[i]*e[k+1]*e[j+1];
}
if (i<=n && j-i+1==n && f[i][j]>max)max=f[i][j];
// printf("%ld ",f[i][j]);
}*/错误代码
for (int j=2;j<n+n;j++)
for (int i=j-1;i>=1 && j-i<n;i--) //区间向左向右扩展的枚举顺序
{
for (int k=i;k<j;k++)
{
long temp=f[i][k]+f[k+1][j]+e[i]*e[k+1]*e[j+1];
if (temp>f[i][j]) f[i][j]=temp;
}
if (f[i][j]>max) max=f[i][j];
}
printf("%ld\n",max);
// getchar(); getchar();
} 

6、切割矩阵（cuts.exe）

给你一个矩阵，其边长均为整数。你想把矩阵切割成总数最少的正方形，其边长也为整数。切割工作由一台切割机器完成，它能沿平行于矩形任一边的方向，从一边开始一直切割到另一边。对得到的矩形再分别进行切割。

输入数据：

输入文件中包含两个正整数，代表矩形的边长，每边长均在1—100之间。

输出数据：

输出文件包含一行，显示出你的程序得到的最理想的正方形数目。

输入输出示例：

CUTS.IN：

5 6

CUTS.OUT:

5

 #include<cstdio>
int n,m;
int f[101][101]; //f[i][j]表示宽为I长为j的矩形最小切割数

int work(int i,int j)
{
if (i>j) { int t=i;i=j;j=t; }
if (i==j) return f[i][j]=1;
if (f[i][j]<200) return f[i][j];
if (i==1) return f[i][j]=j; //这句也可以省略
for (int k=1;k<i;k++) //横切
{
int tmp=work(k,j)+work(i-k,j);
if (tmp<f[i][j]) f[i][j]=tmp;
}
for (int k=1;k<j;k++)//纵切
{
int tmp=work(i,k)+work(i,j-k);
if (tmp<f[i][j]) f[i][j]=tmp;
}
return f[i][j];
}

int main()
{
freopen("cuts.in","r",stdin);
freopen("cuts.out","w",stdout);
scanf("%d%d",&n,&m);
if (n>m) {int t=n;n=m;m=t;} //没有先交换 初始化会出错
for (int i=1;i<=n;i++)
for (int j=1;j<=m;j++) f[i][j]=200; //由于求最小值 初始化成大值
printf("%d\n",work(n,m));
// getchar(); getchar();
}