动态规划练习试题和解答1文档格式.docx

动态规划练习试题和解答1文档格式.docx

《动态规划练习试题和解答1文档格式.docx》由会员分享，可在线阅读，更多相关《动态规划练习试题和解答1文档格式.docx（13页珍藏版）》请在冰豆网上搜索。

375080"

表示第一天机票价格是75KOI,第二天没有航班,第三天的机票是80KOI,然后循环:

第四天又是75KOI,第五天没有航班,如此循环.输入文件由n=k=0的场景结束.

输出:

对每个场景如果乐团可能从城市1出发,每天都要飞往另一个城市,最后（经过k天）抵达城市n,则输出这k个航班价格之和的最小值.如果不可能存在这样的巡回演出路线,输出0.

样例输入:

样例输出：

36460

21301500

375080

712011001001101200

460706050

30135140

27080

23

2070

180

00

[题3]复制书稿（BOOKS）

问题描述：

假设有M本书（编号为1，2，…M），想将每本复制一份，M本书的页数可能不同（分别是P1，P2，…PM）。

任务时将这M本书分给K个抄写员（K〈=M〉，每本书只能分配给一个抄写员进行复制，而每个抄写员所分配到的书必须是连续顺序的。

意思是说，存在一个连续升序数列0=bo〈b1〈b2〈…<

bk-1<

bk=m，这样，第I号抄写员得到的书稿是从bi-1+1到第bi本书。

复制工作是同时开始进行的，并且每个抄写员复制的速度都是一样的。

所以，复制完所有书稿所需时间取决于分配得到最多工作的那个抄写员的复制时间。

试找一个最优分配方案，使分配给每一个抄写员的页数的最大值尽可能小（如存在多个最优方案，只输出其中一种）。

文件的第一行是两个整数m和k（1〈=k〈=m〈=500）。

第二行有m个整数P1，P2，…，Pm，这m个整数均为正整数且都不超过1000000。

每两个整数之间用空格分开。

文件有k行，每行有两个正整数。

整数之间用空格分开。

第I行的两个整数ai和bi，表示第I号抄写员所分配得到的书稿的起始编号与终止编号。

动态规划题参考程序：

题1：

解决问题：

例子的上下部分之差是6+1+1+1-（1+5+3+2）=（6-1）+（1-5）+（1-3）+（1-2）=-2，而翻转最后一个骨牌后，上下之差变为（6-1）+（1-5）+（1-3）+（2-1）=0。

由此看出，一个骨牌对翻转策略造成影响的是上下两数之差，骨牌上的数则是次要的了。

这么一来，便把骨牌的放置状态由8个数字变为4个：

5-4-2-1，翻转时只需取该位数字的相反数就行了。

在本题中，因为各骨牌的翻转顺序没有限定，所以不能按骨牌编号作为阶段来划分。

怎么办呢？

考虑到隐含阶段类型的问题可以按状态最优值的大小来划分阶段。

于是，我们以骨牌序列上下两部分的差值I作为状态，把达到这一状态的翻转步数作为状态值，记为f（I）。

便有f（I）=min{f（I+j）+1}（-12〈=j<

=12,j为偶数，且要求当前状态有差值为j/2的骨牌）。

这里，I不是无限增大或减小，其范围取决于初始骨牌序列的数字差的和的大小。

具体动态规划时，如例题，我们以f（-2）=0起步，根据骨牌状态，进行一次翻转，可得到f（-12）=1，f（6）=1，f

（2）=1，f（0）=1，由于出现了f（0），因此程序便可以结束，否则将根据四个新状态继续扩展，直至出现f（0）或者无法生成新状态为止。

注意：

在各状态，除记录最少步数外，还需记录到达这一状态时各骨牌的放置情况；

而当到达某一状态发现已记录有一种翻转策略时，则取步数较小的一种。

程序如下：

programdomino;

typetp=array[1..6]ofinteger;

vart:

array[1..6000]of^tp;

{记录骨牌摆放状态}

f:

array[-6000..6000]ofinteger;

{记录达到某个差值的最少步数}

l:

array[1..6000]ofinteger;

{扩展队列}

tt:

tp;

i,j,n,m,x,y,ft,re:

integer;

f1,f2:

text;

procedureinit;

{程序初始化}

begin

assign（f1,'

domino.dat'

）;

reset（f1）;

assign（f2,'

domino.out'

rewrite（f2）;

m:

=0;

ft:

re:

=1;

new（t[1]）;

fillchar（t[1]^,sizeof（t[1]^）,0）;

fillchar（f,sizeof（f）,0）;

fillchar（tt,sizeof（tt）,0）;

readln（f1,n）;

fori:

=1tondo

begin

readln（f1,x,y）;

ifx<

>

ythen

x:

=x-y;

inc（m,x）;

inc（tt[abs（x）]）;

ifx>

0theninc（t[1]^[x]）;

end;

ifm=0then

writeln（f2,0）;

close（f2）;

halt;

{处理步数为零的情况}

l[1]:

=m;

f[m]:

end;

proceduremain;

{主过程}

repeat

forft:

=ft+1toredo

{以步数为阶段扩展状态}

=l[ft];

=1to6do

{不同差值的六种情况}

6then

if（t[ft]^[i]<

tt[i]）and（f[x+i*2]=0）then

inc（re）;

l[re]:

=x+i*2;

f[l[re]]:

=f[x]+1;

ifl[re]=0then

{找到解便打印}

writeln（f2,f[l[re]]-1）;

new（t[re]）;

t[re]^:

=t[ft]^;

inc（t[re]^[i]）;

{差值增加}

-6then

if（t[ft]^[i]>

0）and（f[x-i*2]=0）then

=x-i*2;

dec（t[re]^[i]）;

{差值减少}

untilft=re;

if（f[i]>

0）or（f[-i]>

0）then

if（f[-i]>

0）and（（f[i]=0）or（f[-i]<

f[i]））thenx:

=f[-i]

elsex:

=f[i];

writeln（f2,x-1）;

i:

=6;

{骨牌上下两行点数之和的绝对值不为零}

init;

main;

end.

题2：

初看这道题,很容易便可以想到动态规划,因为第x天在第y个地方的最优值只与第x-1天有关,符合动态规划的无后效性原则,即只与上一个状态相关联,而某一天x航班价格不难求出S=C[（x-1）modm+1].我们用天数和地点来规划用一个数组A[1..1000,1..10]来存储,A[i,j]表示第i天到达第j个城市的最优值,C[i,j,l]表示i城市与j城市间第l天航班价格,则A[i,j]=Min{A[i-1,l]+C[l,j,i]（l=1..n且C[l,j,i]<

0）},动态规划方程一出,尽可以放怀大笑了.

示范程序:

programperform_hh;

var

f,fout:

p,l,i,j,n,k:

a:

array[1..1000,1..10]ofinteger;

{动态规划数组}

c:

array[1..10,1..10]ofrecord{航班价格数组}

num:

t:

array[1..30]ofinteger;

e:

array[1..1000]ofinteger;

procedurework;

{人工赋第一天各城市最优值}

ifc[1,i].t[1]<

thena[1,i]:

=c[1,i].t[1];

=2tokdo

forj:

forl:

if（j<

l）

and（c[l,j].t[（i-1）modc[l,j].num+1]<

0）{判断存在航班}

and（（a[i,j]=0）or（a[i-1,l]+c[l,j].t[（i-1）modc[l,j].num+1]<

a[i,j]））{判断比当前解优}

thena[i,j]:

=a[i-1,l]+c[l,j].t[（i-1）modc[l,j].num+1];

{赋值}

e[p]:

=a[k,n];

{第p个场景的最优值}

procedurereadfile;

{读文件}

assign（f,'

PERFORM.DAT'

reset（f）;

assign（fout,'

PERFORM.OUT'

rewrite（fout）;

readln（f,n,k）;

p:

while（n<

0）and（k<

0）do

=p+1;

fillchar（c,sizeof（c）,0）;

fillchar（a,sizeof（a）,0）;

=1toi-1do

read（f,c[i,j].num）;

=1toc[i,j].numdo

read（f,c[i,j].t[l]）;

=i+1tondo

work;

{输出各个场景的解}

=1top-1do

writeln（fout,e[i]）;

write（fout,e[p]）;

close（f）;

close（fout）;

readfile;

[题3：

]

该题中M本书是顺序排列的，K个抄写员选择数也是顺序且连续的。

不管以书的编号，还是以抄写员标号作为参变量划分阶段，都符合策略的最优化原理和无后效性。

考虑到K〈=M，以抄写员编号来划分会方便些。

设F（I，J）为前I个抄写员复制前J本书的最小“页数最大数”。

于是便有F（I，J）=MIN{F（I-1，V），T（V+1，J）}（1〈=I〈=K，I〈=J〈=M-K+I，I-1〈=V〈=J-1〉。

其中T（V+1，J）表示从第V+1本书到第J本书的页数和。

起步时F（1，1）=P1。

观察函数递推式，发现F（I）阶段只依赖于F（I-1）阶段的状态值，编程时可令数组F的范围为（0…1,1…M），便于缩小空间复杂度。

programbooks;

typetp=array[1..500]ofinteger;

tc=array[1..500]oflongint;

varc:

array[1..500]of^tp;

{记录路径}

array[0..1]oftc;

{状态值}

t:

tc;

{书本页数和}

cc:

{链接路径}

i,j,v,k,m,x,y,min,p1,p2:

longint;

{输入部分}

books.dat'

books.out'

readln（f1,m,k）;

ifk=1then

writeln（f2,1,'

'

m）;

{当k=1时,作特殊处理}

=1tomdo

read（f1,j）;

ifi=1thent[1]:

=jelse

t[i]:

=t[i-1]+j;

{累加页数}

=1tokdo

new（c[i]）;

p1:

f[1]:

=t;

{起步状态}

=2tok-1do

{利用函数递推式计算}

p2:

=p1;

p1:

=1-p2;

=itom-k+ido

min:

=maxlongint;

y:

forv:

=i-1toj-1do

iff[p2,v]>

t[j]-t[v]thenx:

=f[p2,v]elsex:

=t[j]-t[v];

minthenbeginmin:

=x;

=v;

f[p1,j]:

=min;

c[i]^[j]:

=y;

=k-1tom-1do

iff[p2,i]>

t[m]-t[i]thenx:

=f[p2,i]elsex:

=t[m]-t[i];

=i;

{最后找出最优分配方案}

=k-1downto1do

cc[i]:

y:

=c[i]^[y];

{链接路径}

cc[1]）;

writeln（f2,cc[j-1]+1,'

cc[j]）;

writeln（f2,cc[k-1]+1,'

{打印}