动态规划解析 浅谈记忆化搜索Word文档下载推荐.docx
《动态规划解析 浅谈记忆化搜索Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《动态规划解析 浅谈记忆化搜索Word文档下载推荐.docx（28页珍藏版）》请在冰豆网上搜索。
if（l[j]>
k）and（d[i]>
=d[j]）thenk:
=l[j];
l[i]:
=k+1;
=1totdo
ifl[i]>
o1theno1:
=l[i];
proceduremain2;
=0totdol[i]:
=maxint;
=1totdobegin
=1too2do
=d[i]）and（l[j]<
=l[k]）thenk:
=j;
ifk=0thenbegin
=o2+1;
=o2;
l[k]:
=d[i];
begin
input;
main1;
main2;
output;
end.
第二题 石子合并
设f[i,j]（i<
=j）表示将第i堆到第j堆石子合并为一堆所得的最大分数（最小时类似）。
问题所求即为f[1,n]。
根据合并规则，f[i,j]的解只于f[i,k],f[k+1,j]（i<
j）的解有关，即问题的最优解包含了子问题的最优解，具备最优子结构。
转移方程为f[i,j]=
{f[i,k]+f[k+1,j]}+
d[p];
初始时f[k,k]=0（1<
=n）;
Programgether_stone;
type
Trock_best=Array[1..100,1..100]oflongint;
Trock_k=Array[1..100,1..100]ofbyte;
Tstone=Array[0..100]ofword;
Tbak=Array[1..100]ofboolean;
var
rock_best:
^Trock_best;
rock_k:
Trock_k;
stone,tot:
Tstone;
stone1:
bak:
Tbak;
n:
Word;
functioncount（first,k,last:
Word）:
longint;
s1:
iffirst<
=last
thens1:
=tot[last]-tot[first-1]
elses1:
=tot[n]+tot[last]-tot[first-1];
count:
=rock_best^[first,k]+rock_best^[（kmodn）+1,last]+s1;
functiontry（now,old:
job:
byte）:
boolean;
if（（job=1）and（now<
old））or（（job=2）and（now>
old））
thentry:
=true
elsetry:
=false;
procedureget（first,last,job:
integer）;
now:
=first;
whilek<
>
lastdo
=count（first,k,last）;
iftry（now,rock_best^[first,last],job）
then
rock_best^[first,last]:
=now;
rock_k[first,last]:
=k;
=（kmodn）+1;
procedureinit;
assign（input,'
input.txt'
reset（input）;
readln（n）;
=1tondo
read（stone[i]）;
close（input）;
tot[0]:
tot[i]:
=tot[i-1]+stone[i];
new（rock_best）;
assign（output,'
output.txt'
rewrite（output）;
procedureinto（job:
byte）;
ifjob=1
thenfillchar（rock_best^,sizeof（rock_best^）,$1）
elsefillchar（rock_best^,sizeof（rock_best^）,0）;
fillchar（rock_k,sizeof（rock_k）,0）;
=1tondorock_best^[i,i]:
=stone[i];
procedureout（first,last:
i,s:
ifnot（（（firstmodn）+1=last）or（first=last））
out（first,rock_k[first,last]）;
out（（rock_k[first,last]modn）+1,last）;
iffirst=lastthenexit;
ifbak[i]=truethen
if（i=first）or（i=（rock_k[first,last]modn）+1）
thenwrite（'
-'
write（stone1[i],'
'
writeln;
bak[（rock_k[first,last]modn）+1]:
iflast>
=first
thens:
elses:
=tot[last]+tot[n]-tot[first-1];
whilei<
stone1[i]:
=s;
=（imodn）+1;
stone1[last]:
procedurework（job:
i,j,k,first,last:
into（job）;
=2tondo
=（（i+j-2）modn）+1;
get（i,j,job）;
=stone;
fillchar（bak,sizeof（bak）,true）;
first:
last:
=n;
if（（rock_best^[i,i-1]<
rock_best^[first,last]）and（job=1））or
（（rock_best^[i,i-1]>
rock_best^[first,last]）and（job=2））
=i-1;
out（first,last）;
writeln（tot[n]）;
init;
work
（1）;
work
（2）;
close（output）;
第三题 乘积最大
问题给出了一个数字串s，求向其中加k个乘号后的最大乘积。
设f[i,j]表示向串s[1..i]中加j个乘号后的最大乘积，n=length（s）。
问题所求即为f[n,k]。
假设最优解中第k个乘号放在第i个字符后，则前k-1个乘号的放置必为子问题“向串s[1..i]中加k-1个乘号”的最优解，所以该问题具备最优子结构。
设num[i,j]表示串s[i..j]所表示的数字，动态规划的转移方程为f[i,j]=
{f[p,j-1]*num[p+1,i]},初始时有f[i,0]=num[1,i]。
constmax1=30;
max2=20;
typearr1=array[1..max1,0..max2]oflongint;
arr2=array[1..max1]oflongint;
varm:
arr1;
num:
arr2;
f:
text;
i,j,k,p,q,l,n:
st:
string;
code:
integer;
functionnumber（a,b:
integer）:
vari,j,m:
m:
j:
=bdowntoadobegin
=m+num[i]*j;
=j*10;
number:
=m;
fillchar（m,sizeof（m）,0）;
fillchar（num,sizeof（num）,0）;
Input:
readln（n,k）;
readln（st）;
=1tondonum[i]:
=ord（st[i]）-ord（'
0'
writeln（m[n,k]）;
proceduremain;
varlin,max:
=1tondom[i,0]:
=number（1,i）;
=2tondobegin
=1to20dobegin
ifj>
i-1thencontinue;
max:
forp:
=i-1downto1dobegin
lin:
=m[p,j-1]*number（p+1,i）;
iflin>
maxthenmax:
=lin;
m[i,j]:
=max;
main;
第四题 方格取数
先看游戏者从A到B只走一次的情况。
只能向下或向右走，这隐含了格子之间的拟序关系，可以根据这种关系划分子问题。
走到格（x,y）所得到的最大分值只于前一步在格（x-1,y）或（x,y-1）所得到的最大分值有关，即问题具备最优子结构。
设f[x,y]表示走到格（x,y）所得到的最大分值，data[x,y]表示格（x,y）的分值，动态规划的转移方程为f[x,y]=max{f[x-1,y],f[x,y-1]}+data[x,y];
初始时f[1,1]=data[1,1]。
类似的，对于走两次的情况，设f[i1,j1,i2,j2]表示第一，二条路线分别到格（i1,j1），（i2,j2）时得到的最大分值。
动态规划转移方程为
f[i1,j1,i2,j2]=max{f[i1-1,j1,i2,j2],f[i1,j1-1,i2,j2],f[i1,j1,i2-1,j2],f[i1,j1,i2,j2-1]}+data[i1,j1]+data[i2,j2]（当（i1,j1）=（i2,j2）时只加一次）），初始时f[1,1,1,1]=data[1,1]。
programget_number;
constmaxn=10;
typearraytype=array[0..maxn,0..maxn]oflongint;
vari,j,k,n,i1,i2,j1,j2:
data:
arraytype;
sum:
array[0..maxn,0..maxn,0..maxn,0..maxn]oflongint;
functionmax（x,y:
longint）:
ifx>
ythenmax:
=xelsemax:
=y;
end;
=1tomaxndo
=1tomaxndodata[i,j]:
readln（i,j,k）;
data[i,j]:
until（i=0）and（j=0）and（k=0）;
fillchar（sum,sizeof（sum）,0）;
fori1:
forj1:
fori2:
forj2:
ifsum[i1-1,j1,i2-1,j2]>
sum[i1,j1,i2,j2]
thensum[i1,j1,i2,j2]:
=sum[i1-1,j1,i2-1,j2];
ifsum[i1-1,j1,i2,j2-1]>
=sum[i1-1,j1,i2,j2-1];
ifsum[i1,j1-1,i2-1,j2]>
=sum[i1,j1-1,i2-1,j2];
ifsum[i1,j1-1,i2,j2-1]>
=sum[i1,j1-1,i2,j2-1];
sum[i1,j1,i2,j2]:
=sum[i1,j1,i2,j2]+data[i1,j1];
if（i1<
i2）or（j1<
j2）
=sum[i1,j1,i2,j2]+data[i2,j2];
Maxscore='
sum[n,n,n,n]）;
第五题 数的划分
设f[i,j]（i>
=j）表示将数i分成j份的方法总数，分两种情况，一是划分后最小的数为1，这种情况包含的方法总数为f[i-1,j-1],一是划分后最小的数大于1，设a1..aj为这种情况下的一种划分，且ai<
=ai+1（1<
=i<
j）,则a1－1..aj－1对应于将数i-j分为j份的一种划分，且这种对应是一一对应，所以这种情况包含的方法总数为f[i-j,j]。
programdp;
constoutputfile='
;
vari,j,k,m,n:
integer;
f:
array[0..200,0..7]oflongint;
read（n,m）;
f[0,0]:
=1tomdo
ifi>
=jthenf[i,j]:
=f[i-j,j]+f[i-1,j-1];
assign（output,outputfile）;
writeln（f[n,m]）;
end.
第六题 统计单词个数
设g[i,l]表示将字串st[1..l]分成i份所能得到的最大单词个数，f[p,ll]表示字串st[p..ll]中包含的最大单词个数。
将字串st[1..l]分成i份的最优解（设其中第i份为st[s..l]）中一定包含了子问题将字串st[1..s]分成i-1份的最优解，问题具备最优子结构。
转移方程为g[i,ll]=
{g[i-1,s]+f[s+1,ll]}。
如何求f[p,ll]呢？
若有两个单词在串st中占有同一个首字母，显然应该选长度小的一个。
可以设wp[i]表示st中以s[i]开头的单词的最小长度，若没有这样的单词，则wp[i]:
串st[p..ll]中包含的单词个数即为
op（wp[i]+i-1<
=ll）,函数op（命题I）当I为真时值为1，I为假时值为0。
若先求f[p+1,ll]后求f[p,ll],可以有f[p,ll]=f[p+1,ll]+op（wp[p]+p-1<
=ll）。
由于当前阶段的状态只于上一阶段有关，实现时运用了滚动数组。
{$A+,B-,D-,E+,F-,G+,I-,L+,N-,O-,P-,Q-,R-,S-,T-,V+,X+}
{$M16384,0,655360}
const
maxn=200;
{maxl=20;
{maxword'
slength}
type
ftype=array[0..1,0..maxn]ofinteger;
var
map:
array[1..maxn,1..maxn]ofbyte;
ff:
text;
nn,k,l,i,maxll:
procedureInit;
i,j,p,o,ll:
s,t,word:
string;
ch:
char;
readln（ff,p,k）;
s:
='
=1topdobegin
read（ff,ch）;
=s+ch;
readln（ff）;
l:
=length（s）;
readln（ff,p）;
fillchar（map,sizeof（map）,0）;
maxll:
readln（ff,word）;
whileword[length（word）]='
dodelete（word,length（word）,1）;
=pos（word,t）;
o:
ll:
=length（word）;
ifll>
maxllthenmaxll:
=ll;
whilej>
0dobegin
map[o+j,ll]:
delete（t,1,j）;
=o+j;
=1toldo
=2tol-i+1do
if（map[i,j]=0）and（map[i,j-1]=1）
thenmap[i,j]:
procedureMain;
i,j,i1,i2,s,ll,o,p,p1,p2,lw
:
g:
array[0..1,0..maxn]ofinteger;
ftype;
fillchar（g,sizeof（g）,0）;
=1tokdobegin
i1:
=imod2;
i2:
=1-i1;
fillchar（g[i2],sizeof（g[i2]）,0）;
fors:
=i-1tol-k+i-1dobegin
{ifl-k+i-s>
maxll
theno:
=maxll
else}o:
=l-k+i;
fillchar（f,sizeof（f）,0）;
=s+1toodobegin
p1:
=pmod2;
p2:
=1-p1;
fillchar（f[p2],sizeof（f[p2]）,0）;
forll:
=ptoodobegin
iff[p2,ll-1]>
f[p1,ll]
thenf[p2,ll]:
=f[p2,ll-1]
elsef[p2,ll]:
=f[p1,ll];
if（map[p,ll-p+1]>
0）and（f[p2,ll]<
f[p1,ll]+1）
=f[p1,ll]+1;
ifg[i2,ll]<
f[p2,ll]+g[i1,s]
theng[i2,ll]:
=f[p2,ll]+g[i1,s]
writeln（g[i2,l]）;
assign（ff,'
input3.dat'
reset（ff）;
readln（ff,nn）;
=1tonndobegin
Init;
Main;
close（ff）;
第七题 低价买入，更低价买入
本题实际上是给出数列a1..an,求最长非递增序列的长度，我们可以用f[k]表示数列a1..ak中以ak结尾的最长非递增序列的长度，题目所求即为max{f[1..n]}。
=a[k]） 初始时，f[0]=0,a[0]=-maxint.
VARN:
WORD;
PRICE:
ARRAY[1..5000]OFREAL;
LIST:
ARRAY[1..
升级会员 