动态规划程序设计(5)

【例】求最长不下降序列

【问题描述】：

设有由n个不相同的整数组成的数列，记为:b(1)、b(2)、……、b(n)且b(i)<>b(j)  (i<>j)，若存在i1<i2<i3< … < ie 且有b(i1)<b(i2)< … <b(ie)则称为长度为e的不下降序列。程序要求，当原数列给出之后，求出最长的不下降序列。

例如13，7，9，16，38，24，37，18，44，19，21，22，63，15。例中13，16，18，19，21，22，63就是一个长度为7的不下降序列，同时也有7 ，9，16，18，19，21，22，63长度为8的不下降序列。

【算法分析】：根据动态规划的原理，由后往前进行搜索。

1）、对b(n)来说，由于它是最后一个数，所以当从b(n)开始查找时，只存在长度为1的不下降序列；

2）、若从b(n-1)开始查找，则存在下面的两种可能性：

①若b(n-1)<b(n)则存在长度为2的不下降序列b(n-1)，b(n)。

②若b(n-1)>b(n)则存在长度为1的不下降序列b(n-1)或b(n)。

3）、一般若从b(i)开始，此时最长不下降序列应该按下列方法求出:

在b(i+1),b(i+2),…,b(n)中，找出一个比b(i)大的且最长的不下降序列，作为它的后继。

【数据结构】：

为算法上的需要，定义一个数组整数类型二维数组b(N,3)

1)、b(i,1)表示第i个数的数值本身；

2)、b(i,2)表示从i位置到达N的最长不下降序列长度

3)、b(i,3)表示从i位置开始最长不下降序列的下一个位置，若b[i,3]=0则表示后面没有连接项。

【求解过程】：

①
    从倒数第二项开始计算，后面仅有1项，比较一次，因63>15，不符合要求，长度仍为1

②
    从倒数第三项开始其后有2项，需做两次比较，得到目前最长的不下降序列为2，如下表：

	11	12	13	14	……		11	12	13	14
		22	63	15	……		21	22	63	15
		2	1	1	……		3	2	1	1
		13	0	0	……		12	13	0	0

【一般处理过程】：

①在i+1,i+2,…,n项中，找出比b[I,1]大的最长长度L以及位置K;

②若L>0，则b[I,2]:=L+1;b[I,3]:=k;

最后本题经过计算，其数据存储表如下：

1	2	3	4	5	6	7	8	9	10	11	12	13	14
13	7	9	16	38	24	37	18	44	19	21	22	63	15
7	8	7	6	3	4	3	5	2	4	3	2	1	1
4	3	4	8	9	7	9	10	13	11	12	13	0	0

初始化:
for i:=1 to n do
begin
  read(b[i,1]);
  b[i,2]:=1;b[i,3]:=0;
end;
下面给出求最长不下降序列的算法:
for i:=n-1 downto 1 do
begin
 L:=0;k:=0;
 for j:=i+1 to n do
  if(b[j,1]>b[i,1])and(b[j,2]>L) then begin
L:=b[j,2];
k:=j;
                                      end;
 if L>0 then begin
b[i,2]:=L+1;
b[i,3]:=k;
             end;
end;
下面找出最长不下降序列：
k:=1;
for j:=1 to n do
 if b[j,2]>b[k,2] then k:=j;
最长不下降序列长度为B(k, 2)序列
while k<>0  do
begin
 write(b[k,1]:4);
 k:=b[k,3];
end;

var 
n,i,L,k,j:integer;
  b:array[1..100,1..3]of integer;
begin
 readln(n);
 for i:=1 to n do
 begin
  read(b[i,1]);
  b[i,2]:=1;b[i,3]:=0;
 end;
for i:=n-1 downto 1 do
  begin
   L:=0;k:=0;
   for j:=i+1 to n do
    if(b[j,1]>b[i,1])and(b[j,2]>L) then begin
L:=b[j,2]; k:=j;
                                         end;
  if L>0 then begin
               b[i,2]:=L+1;b[i,3]:=k;
              end;
 end;
 k:=1;
 for j:=1 to n do
  if b[j,2]>b[k,2] then k:=j;
 writeln('max=',b[k,2]);
 while k<>0  do
  begin
    write(b[k,1]:4);
    k:=b[k,3];
  end;
 writeln;
end.

程序运行结果：

输入：14

13 7 9 16 38 24 37 18 44 19 21 22 63 15

输出：max=8

7  9  16  18  19  21  22  63

var
  i,n,max,st,en:longint;
  b:array[1..100000,1..3] of longint;
procedure Init;
var i:longint;
begin
  readln(n);
  for i:=1 to n do
   begin
     read(b[i,1]);
     b[i,2]:=1; b[i,3]:=0;
   end;
end;
procedure Lis;
var i,j,maxl,loca:longint;
begin
  for i:=n-1 downto 1 do
   begin
     maxl:=0; loca:=0;
     for j:=i+1 to n do
      if b[i,1]<b[j,1] then
        //begin
          if b[j,2]>maxl then
           begin
             maxl:=b[j,2];
             loca:=j;
           end;
        //end;
     if maxl>0 then
      begin
        b[i,2]:=maxl+1;
        b[i,3]:=loca;
      end;
   end;
end;
procedure Findmax;
var i:longint;
begin
  max:=0;
  for i:=1 to n do
   if b[i,2]>max then
    begin
      max:=b[i,2];
      st:=i;
    end;
end;
procedure Outit;
var i:longint;
begin
  writeln(max);
  i:=st;
  while i<>0 do
   begin
     write(b[i,1],' ');
     i:=b[i,3];
   end;
end;
begin
  Init;
  Lis;
  Findmax;
  Outit;
end.

【例】拦截导弹1

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭，由于该系统还在试用阶段。所以只有一套系统，因此有可能不能拦截所有的导弹。输入导弹依次飞来的高度(雷达给出的高度不大于30000的正整数)。计算这套系统最多能拦截多少导弹。

输入：N颗依次飞来的导弹高度，（导弹个数<=1000）。

输出：一套系统最多拦截的导弹数，并依次打印输出被拦截导弹的高度。

在本题中不仅要求输出最优解，而且还要求输出最优解的形成过程。为此，我们设置了一张记忆表C[i]，在按从后往前方式求解的过程中，将每一个子问题的最佳决策保存起来，避免在输出方案时重复计算。

阶段i：     由右而左计算导弹n‥导弹1中可拦截的最多导弹数（1≤i≤n）；

状态B[i]：  由于每个阶段中仅一个状态，因此可通过一重循环

for i := n-1 downto 1 do  枚举每个阶段的状态B[i]；

决策k：在拦截导弹i之后应拦截哪一枚导弹可使得B[i]最大（i+1≤k≤n），

1   2   3   4   5   6   7   8   9   10  11  12  13  14  I

13  7   9   16  38  24  37  18  44  19  21  22  63  15  A[I]    {高度}

2   1   1   2   4   3   3   2   3   2   2   2   2   1   B[I]    {可拦截数}

2   0   0   14  6   8   8   14  10  14  14  14  14  0   C[I]    {再拦截}

var
  a,b,c:array[1..1000] of longint;
  n,i,j,k,max:longint;
begin
 n:=0;                                                           {初始化，读入数据}
 while not eoln do 
begin                                                               {eoln ：行结束}
inc(n);read(a[n]); 
b[n]:=1; c[n]:=0;
  end;
 readln;
 for i:=n-1 downto 1 do                         {枚举每一个阶段的状态，设导弹i被拦截}
begin                  
   max:=0; j:=0;
   for k:=i+1 to n do                      {枚举决策，计算最佳方案中拦截的下一枚导弹}
    if (a[k]<=a[i]) and (b[k]>max) then begin  max:=b[k];j:=k; end;
    b[i]:=max+1; c[i]:=j;                 {若导弹i之后拦截导弹j为最佳方案，则记下}
  end;
  max := 0;
  for i := 1 to n do                                 {枚举求出一套系统能拦截的最多导数}
    if b[i]>max then begin max:=b[i]; j:=i; end;
  writeln('Max = ',b[j]);                                               {打印输出结果}
  while j>0 do 
begin
   write(a[j]:5); j:=c[j];
    end;
 end.