动态规划经典教程
Posted Wss0130
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了动态规划经典教程相关的知识，希望对你有一定的参考价值。
引言：本人在做过一些题目后对DP有些感想，就写了这个总结：
第一节动态规划基本概念
一，动态规划三要素：阶段，状态，决策。
他们的概念到处都是，我就不多说了，我只说说我对他们的理解：
如果把动态规划的求解过程看成一个工厂的生产线，阶段就是生产某个商品的不同的环节，状态就是工件当前的形态，决策就是对工件的操作。显然不同阶段是对产品的一个前面各个状态的小结，有一个个的小结构成了最终的整个生产线。每个状态间又有关联（下一个状态是由上一个状态做了某个决策后产生的）。
下面举个例子：
要生产一批雪糕，在这个过程中要分好多环节：购买牛奶，对牛奶提纯处理，放入工厂加工，加工后的商品要包装，包装后就去销售……，这样没个环节就可以看做是一个阶段；产品在不同的时候有不同的状态，刚开始时只是白白的牛奶，进入生产后做成了各种造型，从冷冻库拿出来后就变成雪糕（由液态变成固态=_=||）。每个形态就是一个状态，那从液态变成固态经过了冰冻这一操作，这个操作就是一个决策。
一个状态经过一个决策变成了另外一个状态，这个过程就是状态转移，用来描述状态转移的方程就是状态转移方程。
经过这个例子相信大家对动态规划有所了解了吧。
下面在说说我对动态规划的另外一个理解：
用图论知识理解动态规划：把动态规划中的状态抽象成一个点，在有直接关联的状态间连一条有向边，状态转移的代价就是边上的权。这样就形成了一个有向无环图AOE网（为什么无环呢？往下看）。对这个图进行拓扑排序，删除一个边后同时出现入度为0的状态在同一阶段。这样对图求最优路径就是动态规划问题的求解。
二，动态规划的适用范围
动态规划用于解决多阶段决策最优化问题，但是不是所有的最优化问题都可以用动态规划解答呢？
一般在题目中出现求最优解的问题就要考虑动态规划了，但是否可以用还要满足两个条件：
最优子结构（最优化原理）
无后效性
最优化原理在下面的最短路径问题中有详细的解答；
什么是无后效性呢？
就是说在状态i求解时用到状态j而状态j就解有用到状态k…..状态N。
而求状态N时有用到了状态i这样求解状态的过程形成了环就没法用动态规划解答了，这也是上面用图论理解动态规划中形成的图无环的原因。
也就是说当前状态是前面状态的完美总结，现在与过去无关。。。
当然，有是换一个划分状态或阶段的方法就满足无后效性了，这样的问题仍然可以用动态规划解。
三，动态规划解决问题的一般思路。
拿到多阶段决策最优化问题后，第一步要判断这个问题是否可以用动态规划解决，如果不能就要考虑搜索或贪心了。当却定问题可以用动态规划后，就要用下面介绍的方法解决问题了：
（1）模型匹配法：
最先考虑的就是这个方法了。挖掘问题的本质，如果发现问题是自己熟悉的某个基本的模型，就直接套用，但要小心其中的一些小的变动，现在考题办都是基本模型的变形套用时要小心条件，三思而后行。这些基本模型在先面的分类中将一一介绍。
（2）三要素法
仔细分析问题尝试着确定动态规划的三要素，不同问题的却定方向不同：
先确定阶段的问题：数塔问题，和走路问题（详见解题报告）
先确定状态的问题：大多数都是先确定状态的。
先确定决策的问题：背包问题。（详见解题报告）
一般都是先从比较明显的地方入手，至于怎么知道哪个明显就是经验问题了，多做题就会发现。
（3）寻找规律法：
这个方法很简单，耐心推几组数据后，看他们的规律，总结规律间的共性，有点贪心的意思。
（4）边界条件法
找到问题的边界条件，然后考虑边界条件与它的领接状态之间的关系。这个方法也很起效。
（5）放宽约束和增加约束
这个思想是在陈启锋的论文里看到的，具体内容就是给问题增加一些条件或删除一些条件使问题变的清晰。
第二节动态规划分类讨论
这里用状态维数对动态规划进行了分类：
1.状态是一维的
1．1下降/非降子序列问题：
问题描述： 挖掘题目的本质，一但抽象成这样的描述就可以用这个方法解
在一个无序的序列a1,a2,a3,a4…an里，找到一个最长的序列满足：ai<=aj<=ak…<=am,且i<j<k…<m.（最长非降子序列）或ai>aj>ak…>am,且i>j>k…>m.（最长下降子序列）。
问题分析：
如果前i-1个数中用到ak (ak>ai或ak<=ai)构成了一个的最长的序列加上第I个数ai就是前i个数中用到i的最长的序列了。那么求用到ak构成的最长的序列有要求前k-1个数中……
从上面的分析可以看出这样划分问题满足最优子结构，那满足无后效性么？显然对于第i个数时只考虑前i-1个数,显然满足无后效性，可以用动态规划解。
分析到这里动态规划的三要素就不难得出了：如果按照序列编号划分阶段，设计一个状态opt[i] 表示前i个数中用到第i个数所构成的最优解。那么决策就是在前i-1个状态中找到最大的opt[j]使得aj>ai(或aj<=ai)，opt[j]+1就是opt[i]的值；用方程表示为：我习惯了这种写法，但不是状态转移方程的标准写法
opt[i]=max(opt[j])+1 (0<=j<i 且aj<=ai) 最长非降子序列
opt[i]=max(opt[j])+1 (0<=j<i 且aj>ai) 最长下降子序列
实现求解的部分代码：
opt[0]:=maxsize；maxsize 为maxlongint或-maxlongint
for i:=1 to n do
for j:=0 to i-1 do
if ( a[j]>a[i]) and (opt[j]+1>opt[i])then
opt[i]:=opt[j]+1;
ans:=-maxlongint;
for i:=1 to n do
if opt[i]>ans thenans:=opt[i]; ans 为最终解
复杂度：从上面的实现不难看出时间复杂度为O（N2），空间复杂度O（N）；
例题1 拦截导弹 (missile.pas/c/cpp) 来源：NOIP1999(提高组)第一题
【问题描述】
某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。
输入导弹依次飞来的高度（雷达给出的高度数据是不大于30000的正整数），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。
【输入文件】missile.in
单独一行列出导弹依次飞来的高度。
【输出文件】missile.out
两行，分别是最多能拦截的导弹数，要拦截所有导弹最少要配备的系统数
【输入样例】
389 207 155 300 299 170 158 65
【输出样例】
6
2
【问题分析】
有经验的选手不难看出这是一个求最长非升子序列问题，显然标准算法是动态规划。
以导弹依次飞来的顺序为阶段，设计状态opt[i]表示前i个导弹中拦截了导弹i可以拦截最多能拦截到的导弹的个数。
状态转移方程：
opt[i]=max(opt[j])+1 (h[i]>=h[j],0=<j<i) h[i]存，第i个导弹的高度
最大的opt[i]就是最终的解。
这只解决了第一问，对于第二问最直观的方法就是求完一次opt[i]后把刚才要打的导弹去掉，在求一次opt[i]直到打完所有的导弹，但这样做就错了。
不难举出反例： 6 1 7 3 2
错解： 6 3 2/1/7 正解：6 1/7 3 2
其实认真分析一下题就回发现：每一个导弹最终的结果都是要被打的，如果它后面有一个比它高的导弹，那打它的这个装置无论如何也不能打那个导弹了，经过这么一分析，这个问题便抽象成在已知序列里找最长上升序列的问题。
求最长上升序列和上面说的求最长非升序列是一样的，这里就不多说了。
复杂度：时间复杂度为O（N2），空间复杂度为O（N）。
【源代码】
program missile;
const
fin='missile.in';
fout='missile.out';
maxn=10000;
var
a,opt:array[0..maxn] of longint;
n,anslen,anstime:longint;
procedure init;
var
x:longint;
begin
assign(input,fin);
reset(input);
assign(output,fout);
rewrite(output);
n:=0;
repeat
inc(n);
read(a[n]);
until seekeof;
end;
procedure main;
var
i,j:longint;
begin
fillchar(opt,sizeof(opt),0);
a[0]:=maxlongint;
for i:=1 to n do
for j:=i-1 downto 0 do
if (a[j]>=a[i]) and(opt[j]+1>opt[i]) then
opt[i]:=opt[j]+1;
anslen:=0;
for i:=1 to n do
if opt[i]>anslen then
anslen:=opt[i];
fillchar(opt,sizeof(opt),0);
a[0]:=-maxlongint;
for i:=1 to n do
for j:=i-1 downto 0 do
if (a[j]<a[i]) and(opt[j]+1>opt[i]) then
opt[i]:=opt[j]+1;
anstime:=0;
for i:=1 to n do
if opt[i]>anstime then
anstime:=opt[i];
end;
procedure print;
begin
writeln(anslen);
writeln(anstime);
close(input);
close(output);
end;
begin
init;
main;
print;
end.
例题二 合唱队形 (chorus.pas/c/cpp) 来源：NOIP2004(提高组) 第一题
N位同学站成一排，音乐老师要请其中的(N-K)位同学出列，使得剩下的K位同学排成合唱队形。
合唱队形是指这样的一种队形：设K位同学从左到右依次编号为1，2…，K，他们的身高分别为T1，T2，…，TK， 则他们的身高满足T1<...<Ti>Ti+1>…>TK(1<=i<=K)。
你的任务是，已知所有N位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。
【输入文件】
输入文件chorus.in的第一行是一个整数N(2<=N<=100)，表示同学的总数。第一行有n个整数，用空格分隔，第i个整数Ti(130<=Ti<=230)是第i位同学的身高(厘米)。
【输出文件】
输出文件chorus.out包括一行，这一行只包含一个整数，就是最少需要几位同学出列。
【样例输入】
8
186 186 150 200 160 130 197 220
【样例输出】
4
【数据规模】
对于50％的数据，保证有n<=20；
对于全部的数据，保证有n<=100。
【问题分析】
出列人数最少，也就是说留的人最多，也就是序列最长。
这样分析就是典型的最长下降子序列问题。只要枚举每一个人站中间时可以的到的最优解。显然它就等于，包括他在内向左求最长上升子序列，向右求最长下降子序列。
我们看一下复杂度：
计算最长下降子序列的复杂度是O（N2），一共求N次，总复杂度是O（N3）。这样的复杂度对于这个题的数据范围来说是可以AC的。但有没有更好的方法呢？
其实最长子序列只要一次就可以了。因为最长下降（上升）子序列不受中间人的影响。
只要用OPT1求一次最长上升子序列，OPT2求一次最长下降子序列。这样答案就是N-max(opt1[i]+opt2[i]-1).
复杂度由O（N3）降到了O（N2）。
【源代码】
program chorus;
const
fin='chorus.in';
fout='chorus.out';
maxn=200;
var
opt1,opt2,a:array[0..maxn] oflongint;
n,ans:longint;
procedure init;
var
i:longint;
begin
assign(input,fin);
reset(input);
assign(output,fout);
rewrite(output);
readln(n);
for i:=1 to n do
read(a[i]);
end;
procedure main;
var
i,j:longint;
begin
a[0]:=-maxlongint;
for i:=1 to n do
for j:=i-1 downto 0 do
if (a[j]<a[i]) and(opt1[j]+1>opt1[i]) then
opt1[i]:=opt1[j]+1;
a[n+1]:=-maxlongint;
for i:=n downto 1 do
for j:=i+1 to n+1 do
if (a[j]<a[i]) and(opt2[j]+1>opt2[i]) then
opt2[i]:=opt2[j]+1;
ans:=0;
for i:=1 to n do
if opt1[i]+opt2[i]>ans then
ans:=opt1[i]+opt2[i];
end;
procedure print;
begin
writeln(n-ans+1);
close(input);
close(output);
end;
begin
init;
main;
print;
end.
例题3 Buy Low BuyLower (buylow.pas/c/cpp) 来源: USACO 4-3-1
【问题描述】
“逢低吸纳”是炒股的一条成功秘诀。如果你想成为一个成功的投资者，就要遵守这条秘诀:
"逢低吸纳,越低越买"
这句话的意思是：每次你购买股票时的股价一定要比你上次购买时的股价低.按照这个规则购买股票的次数越多越好，看看你最多能按这个规则买几次。
给定连续的N天中每天的股价。你可以在任何一天购买一次股票，但是购买时的股价一定要比你上次购买时的股价低。写一个程序，求出最多能买几次股票。
以下面这个表为例, 某几天的股价是:
天数 1 2 3 4 5 6 7 8 9 10 11 12
股价 68 69 54 64 68 64 70 67 78 62 98 87
这个例子中, 聪明的投资者(按上面的定义)，如果每次买股票时的股价都比上一次买时低，那么他最多能买4次股票。一种买法如下(可能有其他的买法):
天数 2 5 6 10
股价 69 68 64 62
【输入文件】buylow.in
第1行: N (1 <= N <= 5000), 表示能买股票的天数。
第2行以下: N个正整数 (可能分多行) ，第i个正整数表示第i天的股价. 这些正整数大小不会超过longint(pascal)/long(c++).
【输出文件】buylow.out
只有一行，输出两个整数：
能够买进股票的天数长度达到这个值的股票购买方案数量
在计算解的数量的时候，如果两个解所组成的字符串相同，那么这样的两个解被认为是相同的（只能算做一个解）。因此，两个不同的购买方案可能产生同一个字符串，这样只能计算一次。
【输入样例】
12
68 69 54 64 68 64 70 67
78 62 98 87
【输出样例】
4 2
【问题分析】
从题目描述就可以看出这是最长下降子序列问题，于是求解第一问不是难事，以天数为阶段，设计状态opt[i] 表示前i天中要买第i天的股票所能得到的最大购买次数。
状态转移方程：
opt[i]=max(opt[j])+1 (a[i]>=a[j],0=<j<i) a[i]存第i天股价
最大的opt[i]就是最终的解。
第二问呢，稍麻烦一点。
从问题的边界出发考虑问题，当第一问求得一个最优解opt[i]=X时，
在1到N中如果还有另外一个opt[j]=x那么选取J的这个方案肯定是成立的。
是不是统计所有的opt[j]=x 的个数就是解了呢？
显然没那么简单，因为选取Ｊ这天的股票构成的方案不见得＝１，看下面一个例子：
５ 6 4 3 １ 2
方案一：５４３１
方案二：５４３２
方案三：６４３１
方案四：６４３２
x=4
也就是所虽然opt[5]=X 和opt[6]=X但个数只有两个，而实际上应该有四个方案，但在仔细观察发现，构成opt[5]=x 的这个方案中 opt[j]=x-1的方案数有两个,opt[j]=x-2的有一个，opt[j]=x-3 的有一个……
显然这是满足低归定义的设计函数F（i）表示前I张中用到第i张股票的方案数。
递推式：
1 (i=0)
F(i)=
Sum(F(j)) (0<=j<=n,a[j]>a[i],opt[j]=opt[i]-1) sum 代表求和
答案=sum(F(j)) 0<j<=n,opt[j]=x
复杂度：
求解第一问时间复杂度是O(N2),求解第二问如果用递推或递归+记忆化时间复杂度仍为O（N2）但要是用赤裸裸的递归那就复杂多了……，因为那样造成了好多不必要的计算。
你认为这样做就解决了这道题目了么？还没有，还要注意一些东西：
（1）如果有两个方案中出现序列一样，视为一个方案，要需要加一个数组next用next[i] 记录和第i个数情况一样（即：opt[i]=opt[j] 且 a[i]=a[j]）可看做一个方案的最近的位置。
递推时j只要走到next[i]即可。
（2）为了方便操作可以将a[n+1]赋值为-maxlongint这样可以认为第n+1个一定可以买，答案就是sum(F(n+1))。
（3）看数据规模显然要用高精度。
注：USACO上最后一个点错了。我在程序中做了处理。
【源代码】
program buylow;
const
fin='buylow.in';
fout='buylow.out';
maxn=5010;
maxsize=10;
jz=100000000;
type
arrtype=array[0..maxsize] of longint;
var
a,opt,next:array[0..maxn] of longint;
F:array[0..maxn] of arrtype;
n:longint;
procedure init;
var
i:longint;
begin
assign(input,fin);
reset(input);
assign(output,fout);
rewrite(output);
readln(n);
if n=5then 最后一个点错了，我只好这么写了
begin
writeln('2 5');
close(input);
close(output);
halt;
end;
for i:=1 to n do
read(a[i]);
end;
procedure Hinc(varx:arrtype;y:arrtype);
var
i,z:longint;
begin
z:=0;
for i:=1 to maxsize do
begin
z:=z div jz+x[i]+y[i];
x[i]:=z mod jz;
end;
end;
procedure main;
var
i,j:longint;
begin
a[0]:=maxlongint;
a[n+1]:=-maxlongint;
for i:=1 to n+1 do
for j:=0 to i-1 do
if (a[j]>a[i]) and(opt[j]+1>opt[i]) then
opt[i]:=opt[j]+1;
for i:=1 to n do
begin
j:=i-1;
while (j>0) and((opt[i]<>opt[j]) or (a[i]<>a[j])) do
dec(j);
next[i]:=j;
end;
F[0,1]:=1;
for i:=1 to n+1 do
for j:=i-1 downto next[i] do
if (opt[j]=opt[i]-1) and(a[j]>a[i]) then
Hinc(F[i],F[j]);
end;
procedure print;
var
i,top,m:longint;
begin
write(opt[n+1]-1,' ');
top:=maxsize;
while (top>1) and (F[n+1][top]=0)do
dec(top);
write(F[n+1,top]);
for i:=top-1 downto 1 do
begin
m:=F[n+1,i];
while m<maxsize div 10 do
begin
write('0');
m:=m*10;
end;
write(F[n+1,i]);
end;
writeln;
close(input);
close(output);
end;
begin
init;
main;
print;
end.
例题4 船 (ships.pas/c/cpp) 来源：《奥赛经典》（提高篇）
【问题描述】
PALMIA国家被一条河流分成南北两岸，南北两岸上各有N个村庄。北岸的每一个村庄有一个唯一的朋友在南岸，且他们的朋友村庄彼此不同。
每一对朋友村庄想要一条船来连接他们，他们向政府提出申请以获得批准。由于河面上常常有雾，政府决定禁止船只航线相交（如果相交，则很可能导致碰船）。
你的任务是编写一个程序，帮助政府官员决定批准哪些船只航线，使得不相交的航线数目最大。
【输入文件】ships.in
输入文件由几组数据组成。每组数据的第一行有2个整数X，Y，中间有一个空格隔开，X代表PALMIA河的长度（10<=X<=6000），Y代表河的宽度（10<=Y<=100）。第二行包含整数N，表示分别坐落在南北两岸上的村庄的数目（1<=N<=5000）。在接下来的N行中，每一行有两个非负整数C，D，由一个空格隔开，分别表示这一对朋友村庄沿河岸与PALMIA河最西边界的距离（C代表北岸的村庄，D代表南岸的村庄），不存在同岸又同位置的村庄。最后一组数据的下面仅有一行，是两个0，也被一空格隔开。
【输出文件】ships.out
对输入文件的每一组数据，输出文件应在连续的行中表示出最大可能满足上述条件的航线的数目。
【输入样例】
30 4
7
22 4
2 6
10 3
15 12
9 8
17 17
4 2
0 0
【输出样例】
4
【问题分析】
这道题目相对来说思考难度较高，从字面意义上看不出问题的本质来，有点无法下手的感觉。这里我给大家推荐两种思考这类问题的方法。
法一：寻找规律法（我前面总结提到的第3个方法）
寻找规律自然要推几组数据，首先当然有从样例入手；
仔细观察上图：红色航线是合法的，那么他们满足什么规律呢？
C1 C2 C3 C4
北岸红线的端点： 4 9 15 17
南岸红线的端点： 2 8 12 17
D1 D2 D3 D4
不难看出无论线的斜率如何，都有这样的规律：
C1<C2<C3<C4 且 D1<D2<D3<D4
如果我们把输入数据排升序，问题变抽象为：
在一个序列（D）里找到最长的序列满足DI<DJ<Dk……且i<j<k
这样的话便是典型的最长非降子序列问题了。。。。
法二：边界条件法（我前面总结提到的第4个方法）
边界法其实就是把数据往小了缩，显然N=1是答案是1。N=2时呢？
考虑这样一组数据：
N=2
C1 D1
C2 D2
当 C1<C2 时，如果D1>D2 那么一定会相交，反之则不会相交。
当C1 >C2时，如果D1<D2 那么一定会相交，反之则不会相交。
N=3
C1 D1
C2 D2
C3 D3
……
其实不用在推导N=3了，有兴趣的可以推导去。看N=2时就能得出：
对于任意两条航线如果满足Ci<Cj 且Di<Dj 则两条航线不相交。这样的话要想在一个序列里让所有的航线都不相交那比然满足，C1<C2<C3…Cans且D1<D2<D3…<Dans ，也就是将C排序后求出最长的满足这个条件的序列的长度就是解。
这样分析后显然是一个最长非降子序列问题。
复杂度：排序可以用O（nlogn）的算法，求最长非降子序列时间复杂度是O(n2).
总复杂度为O（n2）.
【源代码】
program ships;
const
fin='ships.in';
fout='ships.out';
maxn=5010;
type
retype=record
C,D:longint;
end;
var
x,y,n,ans:longint;
a:array[0..maxn] of retype;
opt:array[0..maxn] of longint;
procedure init;
var
i:longint;
begin
readln(n);
for i:=1 to n do
read(a[i].c,a[i].d);
end;
procedure quick(L,r:longint);
var
i,j,x:longint;
y:retype;
begin
i:=L;
j:=r;
x:=a[(i+j) div 2].c;
repeat
while a[i].c<x do
inc(i);
while a[j].c>x do
dec(j);
if i<=j then
begin
y:=a[i];
a[i]:=a[j];
a[j]:=y;
inc(i);
dec(j);
end;
until i>j;
if j>L then quick(L,j);
if i<r then quick(i,r);
end;
procedure main;
var
i,j:longint;
begin
fillchar(opt,sizeof(opt),0);
quick(1,n);
for i:=1 to n do
for j:=0 to i-1 do
if (a[j].d<a[i].d) and(opt[j]+1>opt[i]) then
opt[i]:=opt[j]+1;
ans:=-maxlongint;
for i:=1 to n do
if ans<opt[i] then
ans:=opt[i];
writeln(ans);
end;
begin
assign(input,fin);
reset(input);
assign(output,fout);
rewrite(output);
read(x,y);
while (x+y<>0) do
begin
init;
main;
read(x,y);
end;
close(input);
close(output);
end.
1.2背包问题
首先说说背包问题的基本模型：
现有N个物品，每个物品的价值为V，重量为W。求用一个载重量为S的背包装这写物品，使得所装物品的总价值最高。
背包问题用贪心和搜索解，当然效果不佳，不过在我的贪心和搜索总结中会说到。显然标准的解法是动态规化，我在解决这个问题时习惯设计一维状态，还可以设计二维的，二维状态在下面会讲，现在只讨论用一维状态实现背包问题。
背包问题的分类：
(1)小数背包:物品的重量是实数，如油，水等可以取1.67升……
(2)整数背包：<1>0/1背包：每个物品只能选一次，或不选。不能只选一部分
<2>部分背包：所选物品可以是一部分。
(3)多重背包：背包不只一个。
小数背包：在贪心总结中会细讲。
整数背包：
部分背包：同小数背包。
0/1背包：这个问题是最经常出现的问题，应该熟练掌握。
我们先看一下0/1背包的简化版：
现有N个物品，每个物品重量为W，这些物品能否使在载重量为S的背包装满（即重量和正好为S）？如过不能那能使物品重量和最重达到多少？
针对这一问题我们以物品的个数分阶段，设计一个状态opt[i]表示载重量为i的背包可否装满，显然opt[i]的基类型是boolean。
决策是什么呢？
当要装第i个物品时，如果前i-1个物品可以使载重为 k的背包装满，那么载重为k+w[i]的背包就可以装满。于是对于一个opt[j]来说，只要opt[j-w[i]]是true（表示可装满）那opt[j]就可以装满，但要注意：针对每一个物品枚举背包的载重量时如果这样正向的推导会使同一个物品用好几次，因为k+w[i]可装满那k+w[i]+w[i]就可装满，但实际上是装不满的因为物品只有一个。解决这个问题很简单，只要逆向推导就OK了。
这样划分阶段，设计状态，满足无后效性和么？
显然对与一个每一个阶段都是独立的，物品的顺序并不影响求解，因为装物品的次序不限。而对于opt[j]只考虑opt[j-w[i]]而不考虑后面的，所以满足无后效性。
有了上面的分析不难写出状态转移方程：
opt[j]:=opt[j-w[1]] opt[j-w[i]]=true
时间复杂度：
阶段数O(S)*状态数（O(N)）*转移代价（O(1)）=O（SN）
下面看几个例题：
例题5 装箱问题 (pack.pas/c/cpp) 来源：NOIP2001(普及组)第四题
【问题描述】
有一个箱子容量为V（正整数，0＜＝V＜＝20000），同时有n个物品（0＜n＜＝30＝，每个物品有一个体积（正整数）。
要求n个物品中，任取若干个装入箱内，使箱子的剩余空间为最小。
【输入文件】
第一 行一个正整数V表示箱子的容量，第二行一个正整数N表示物品个数，接下来N行列出这N个物品各自的体积。
【输出文件】
单独一行，表示箱子最小的剩余空间。
【输入样例】
24
6
8
3
12
7
9
7
【输出样例】
0
【问题分析】
本题是经典的0/1背包问题，并且是0/1背包的简化版，把箱子看做背包，容量看做载重量，体积看做重量，剩余空间最小也就是尽量装满背包。于是这个问题便成了：
有一个栽重量为V的背包，有N个物品，尽量多装物品，使背包尽量的重。
设计一个状态opt[i]表示重量i可否构成。
状态转移方程：opt[j]:=opt[j-w[1]] opt[j-w[i]]=true
最终的解就是v-x（x<=n 且opt[x]=true 且 opt[x+1..n]=false）。
【源代码1】
program pack;
const
fin='pack.in';
fout='pack.out';
maxv=20010;
maxn=100;
var
opt:array[0..maxv] of boolean;
w:array[0..maxn] of longint;
v,n,x:longint;
procedure init;
var
i:longint;
begin
assign(input,fin);
reset(input);
assign(output,fout);
rewrite(output);
read(v);
read(n);
for i:=1 to n do
read(w[i]);
end;
procedure main;
var
i,j:longint;
begin
fillchar(opt,sizeof(opt),false);
opt[0]:=true;
for i:=1 to n do
for j:=v downto w[i] do
if opt[j-w[i]] then opt[j] :=true;
x:=v;
while not opt[x] do dec(x);
end;
procedure print;
begin
writeln(v-x);
close(input);
close(output);
end;
begin
init;
main;
print;
end.
例题6 砝码称重 来源：NOIP1996（提高组） 第四题
【问题描述】
设有1g、2g、3g、5g、10g、20g的砝码各若干枚（其总重<=1000），用他们能称出的重量的种类数。
【输入文件】
a1 a2 a3 a4 a5 a6
（表示1g砝码有a1个，2g砝码有a2个，…，20g砝码有a6个，中间有空格）。
【输出文件】
Total=N
（N表示用这些砝码能称出的不同重量的个数，但不包括一个砝码也不用的情况）。
【输入样例】
1 1 0 0 0 0
【输出样例】
TOTAL=3
【问题分析】
把问题稍做一个改动，已知a1+a2+a3+a4+a5+a6个砝码的重量w[i], w[i]∈ 1,2,3,5,10,20 其中砝码重量可以相等，求用这些砝码可称出的不同重量的个数。
这样一改就是经典的0/1背包问题的简化版了，求解方法完全和上面说的一样，这里就不多说了，只是要注意这个题目不是求最大载重量，是统计所有的可称出的重量的个数。
【源代码1】
program P4;
const
maxn=1010;
w:array[1..6] oflongint=(1,2,3,5,10,20);
var
opt:array[0..maxn] of boolean;
a:array[1..6] of longint;
procedure init;
var
i:longint;
begin
for i:=1 to 6 do
read(a[i]);
end;
procedure main;
var
i,j,k:longint;
begin
fillchar(opt,sizeof(opt),false);
opt[0]:=true;
for i:=1 to 6 do
for j:=1 to a[i] do
for k:=maxn downto w[i] do
if opt[k-w[i]] then opt[k]:=true;
end;
procedure print;
var
ans,i:longint;
begin
ans:=0;
for i:=1 to maxn do
if opt[i] then
inc(ans);
writeln(ans);
end;
begin
init;
main;
print;
end.
例题7 积木城堡 来源：vijos P1059
【问题描述】
XC的儿子小XC最喜欢玩的游戏用积木垒漂亮的城堡。城堡是用一些立方体的积木垒成的，城堡的每一层是一块积木。小XC是一个比他爸爸XC还聪明的孩子，他发现垒城堡的时候，如果下面的积木比上面的积木大，那么城堡便不容易倒。所以他在垒城堡的时候总是遵循这样的规则。
小XC想把自己垒的城堡送给幼儿园里漂亮的女孩子们，这样可以增加他的好感度。为了公平起见，他决定把送给每个女孩子一样高的城堡，这样可以避免女孩子们为了获得更漂亮的城堡而引起争执。可是他发现自己在垒城堡的时候并没有预先考虑到这一点。所以他现在要改造城堡。由于他没有多余的积木了，他灵机一动，想出了一个巧妙的改造方案。他决定从每一个城堡中挪去一些积木，使得最终每座城堡都一样高。为了使他的城堡更雄伟，他觉得应该使最后的城堡都尽可能的高。
任务：
请你帮助小XC编一个程序，根据他垒的所有城堡的信息，决定应该移去哪些积木才能获得最佳的效果。
【输入文件】
第一行是一个整数N(N<=100)，表示一共有几座城堡。以下N行每行是一系列非负整数，用一个空格分隔，按从下往上的顺序依次给出一座城堡中所有积木的棱长。用-1结束。一座城堡中的积木不超过100块，每块积木的棱长不超过100。
【输出文件】
一个整数，表示最后城堡的最大可能的高度。如果找不到合适的方案，则输出0。
【输入样例】
2
2 1 –1
3 2 1 -1
【输出样例】
3
【提交链接】
【问题分析】
首先要说明一点，可以挪走任意一个积木，不见得是最上面的。
初看题目有点茫然，但抽象一下就。。。。。。。。。。
其实塔好积木在拿走就相当于当初搭的时候没选拿走的积木。这样一转化思维问题就清楚了。把积木可搭建的最大高度看做背包的载重，每块积木的高度就是物品的重量。也就是用给定的物品装指定的包，使每个包装的物品一样多，且在符合条件的前提下尽量多。
这样就变成经典的背包问题了。
对于每一个城堡求一次，最终找到每一个城堡都可达到的最大高度即可。
【源代码1】
const
maxhig=7000;
maxn=100;
var
n,top:longint;
opt:array[0..maxn,0..maxhig] ofboolean;
a:array[0..maxn] of longint;
procedure init;
var
i:longint;
begin
readln(n);
fillchar(opt,sizeof(opt),false);
for i:=1 to n do
opt[i,0]:=true;
end;
function can(m:longint):boolean;
var
i:longint;
begin
can:=true;
for i:=1 to n do
if not opt[i,m] then
exit(false);
end;
procedure main;
var
ii,m,tothig,i,j,ans:longint;
begin
for ii:=1 to n do
begin
top:=0;
read(m);
tothig:=0;
while m>0 do
begin
inc(top);
a[top]:=m;
inc(tothig,m);
read(m);
end;
for i:=1 to top do
for j:=tothig downto 1 do
if (j-a[i]>=0) and (opt[ii,j-a[i]])then
opt[ii,j]:=true;
end;
ans:=maxhig;
while not opt[1,ans] do
dec(ans);
while not can(ans) do
dec(ans);
writeln(ans);
end;
begin
init;
main;
end.
回顾上面的内容充分说明动态规划的本质就是递推。其实按照我的理解（动规涉及最优决策，递推是单纯的总结）背包问题的简化版更准确点算是递推而非动态规划，至于动归和递推之间的界线本来就很模糊（至少我这么认为）把它看做什么都可以，没必要咬文嚼字。
回到0/1背包的原问题上（如果你忘了就去上面看看）。
如果在不知道这个模型的情况下我们怎么做这个题呢？
这就要用到第一节提到的方法二：三要素法。
题目中明确说明对于一个物品要不就拿走要不就放下，其实题目赤裸裸的告诉我们决策就是不拿（用0表示）或拿（用1表示）。这样想都不用想就知道了决策，这也是本题的突破口。知道了决策写个搜索的程序应该是很轻松的了。
那么阶段是什么呢？
显然，给你一堆东西让你往包里塞，你当然是一个一个的那来，塞进去。那么阶段很明显就是物品的个数。
状态又是什么呢？
有的人在装东西是有个习惯（比如说我）就是先把东西分类，然后把同类的东西打个小包，最后在把小包放进去，我们可以按这个思想给物品打一些小包，也就是按照单位为1的递增的顺序准备好多小包，比如载重是6的包，可以为它准备载重是1，2，3，4，5的小包。这样状态就可以想出来了：
设计状态opt[i，j]表示装第i个物品时载重为j的包可以装到的最大价值。
opt[i-1,j] (j-w[i]<0，i>0)
状态转移方程：opt[i,j]=
maxopt[i-1,j],opt[i-1,j-w[i]]+v[i](j-w[i]>=0,i>0)
(w[i]:第i个物品的重量，v[i]第i个物品的价值)
解释：要载重为j的背包空出w[i]（j-w[i]）的空间且装上第i个物品，比不装获得的价值大就装上它。
边界条件：opt[0,i]=0; (i∈1..S)
注：
这种二维的状态表示应该在下节讲，但是为了方便理解先在这里说了。
上面的方法动态规划三要素都很明显，实现也很简单。但是在我初学背包时却用另外一种一维的状态表示法。
用第一节说的思考方法五（放宽约束和增加约束）在重新思考一下这个问题：
怎么放宽约束呢？
把题目中的价值去掉，不考虑价值即最优就变成背包问题的简化版了。那简化版的求解对我们有何启示呢？
再一次增加约束：背包只能装满。
显然对于N个装满背包的方案中只要找到一个价值最大的就是问题的解。那么装不满怎么办呢？其实装不满背包，它总要达到一定的重量（X）。我们可以把这种情况看作是装满一个载重为X的小包。
总结一下上面的思维过程：
放宽约束让我们找到问题的突破口——和背包问题简化版一样，我们可以却定载重为S的背包是否可以装满。
增加约束让我们找到问题的求解方法——在装满背包的方案中选择最优的一个方案。
这样问题就解决了。
设计一个状态opt[j]表示装满载重为j的背包可获得的最大价值。对于第i个物品，只要opt[j-w[i]]可以装满且opt[j-w[i]]+v[i]比opt[j]大就装上这个物品（更新opt[j]）。
怎么使opt[j]既有是否构成又有最优的概念呢？
opt[j]只表示最优，只不过使初始条件+1，判断opt[j]是否为0，如果opt[j]=0说明j装不满。
边界条件：opt[0]=1;
状态转移方程：opt[j]=maxopt[j-w[i]] (0<i<n,w[i]<=j<=S)
问题解：ans=maxopt[i]-1 (0<i<=s)
时间复杂度：阶段数O(S)*状态数（O(N)）*转移代价（O(1)）=O（SN）
下面看几个例题：
例题8 采药 (medic.pas/c/cpp) 来源：NOIP2005（普及组）第三题
【问题描述】
辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。”
如果你是辰辰，你能完成这个任务吗？
【输入文件】
输入文件medic.in的第一行有两个整数T（1 <= T <= 1000）和M（1 <= M <= 100），用一个空格隔开，T代表总共能够用来采药的时间，M代表山洞里的草药的数目。接下来的M行每行包括两个在1到100之间（包括1和100）的整数，分别表示采摘某株草药的时间和这株草药的价值。
【输出文件】
输出文件medic.out包括一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。
【输入样例】
70 3
71 100
69 1
1 2
【输出样例】
3
【数据规模】
对于30%的数据，M <= 10；
对于全部的数据，M <= 100。
【问题分析】
这是一道典型的0/1背包问题，把时间看做标准模型中的重量，把规定的时间看做载重为T的背包，这样问题和基本模型就一样了，具体实现这里不多说了。
【源代码1】 二维状态
program medic;
const
fin='medic.in';
fout='medic.out';
maxt=1010;
maxn=110;
var
opt:array[0..maxn,0..maxt] oflongint;
w,v:array[0..maxn] of longint;
t,n:longint;
procedure init;
var
i:longint;
begin
assign(input,fin);
reset(input);
assign(output,fout);
rewrite(output);
read(t,n);
for i:=1 to n do
read(w[i],v[i]);
close(input);
end;
function max(x,y:longint):longint;
begin
if x>y then max:=x
else max:=y;
end;
procedure main;
var
i,j:longint;
begin
fillchar(opt,sizeof(opt),0);
for i:=1 to n do
for j:=1 to t do
if j-w[i]<0 then
opt[i,j]:=opt[i-1,j]
elseopt[i,j]:=max(opt[i-1,j],opt[i-1,j-w[i]]+v[i]);
end;
procedure print;
begin
writeln(opt[n,t]);
close(output);
end;
begin
init;
main;
print;
end.
【源代码2】 一维状态
program medic;
const
fin='medic.in';
fout='medic.out';
maxt=1010;
maxn=110;
var
opt:array[0..maxt] of longint;
w,v:array[0..maxn] of longint;
ans,t,n:longint;
procedure init;
var
i:longint;
begin
assign(input,fin);
reset(input);
assign(output,fout);
rewrite(output);
readln(t,n);
for i:=1 to n do
read(w[i],v[i]);
close(input);
end;
procedure main;
var
i,j:longint;
begin
fillchar(opt,sizeof(opt),0);
opt[0]:=1;
for i:=1 to n do
for j:=t downto w[i] do
if (opt[j-w[i]]>0) and(opt[j-w[i]]+v[i]>opt[j]) then
opt[j]:=opt[j-w[i]]+v[i];
ans:=-maxlongint;
for i:=1 to t do
if opt[i]>ans then ans:=opt[i];
end;
procedure print;
begin
writeln(ans-1);
close(output);
end;
begin
init;
main;
print;
end.
例题9 开心的金明 来源：NOIP2006（普及组）第二题
【问题描述】
金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间他自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过N 元钱就行”。今天一早金明就开始做预算，但是他想买的东西太多了，肯定会超过妈妈限定的N 元。于是，他把每件物品规定了一个重要度，分为5 等：用整数1~5 表示，第5 等最重要。他还从因特网上查到了每件物品的价格（都是整数元）。他希望在不超过N 元（可以等于N 元）的前提下，使每件物品的价格与重要度的乘积的总和最大。设第j 件物品的价格为v[j]，重要度为w[j]，共选中了k 件物品，编号依次为j1...jk，则所求的总和为：v[j1]*w[j1]+..+v[jk]*w[jk]请你帮助金明设计一个满足要求的购物单.
【输入文件】
输入的第1 行，为两个正整数，用一个空格隔开： N m
（其中N（<30000）表示总钱数，m(<25)为希望购买物品的个数。）
从第2 行到第m+1 行，第j 行给出了编号为j-1的物品的基本数据，每行有2 个非负整数 v p
（其中v 表示该物品的价格（v≤10000），p 表示该物品的重要度（1~5））
【输出文件】
输出只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值（<100000000）
【输入样例】
1000 5
800 2
400 5
300 5
400 3
200 2
【输出样例】
3900
【问题分析】
这仍然是一到典型的0/1背包，只不过注意这个问题中的价值对应背包模型中的重量，这个问题中的价值和重要度的成绩是背包模型中的价值。（很饶口啊）。
具体实现同背包模型一样，这里不多说了。
【源代码】
program p2;
const
maxn=30010;
maxm=30;
var
opt:array[0..maxn] of longint;
v,p:array[0..maxm] of longint;
n,m:longint;
procedure init;
var
i:longint;
begin
readln(n,m);
for i:=1 to m do
readln(v[i],p[i]);
end;
procedure main;
var
i,j:longint;
begin
fillchar(opt,sizeof(opt),0);
opt[0]:=1;
for i:=1 to m do
begin
for j:=n downto 1 do
begin
if (j-v[i]>=0) and(opt[j-v[i]]>0) and (opt[j-v[i]]+v[i]*p[i]>opt[j])then
opt[j]:=opt[j-v[i]]+v[i]*p[i];
end;
end;
end;
procedure print;
var
i,ans:longint;
begin
ans:=0;
for i:=1 to n do
if opt[i]>ans then
ans:=opt[i];
writeln(ans-1);
end;
begin
init;
main;
print;
end.
例题10 金明的预算方案 (budget.pas/c/cpp) 来源：NOIP2006第二题
【问题描述】
金明今天很开心，家里购置的新房就要领钥匙了，新房里有一间金明自己专用的很宽敞的房间。更让他高兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过N元钱就行”。今天一早，金明就开始做预算了，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：
| 主件 | 附件 |
| 电脑 | 打印机，扫描仪 |
| 书柜 | 图书 |
| 书桌 | 台灯，文具 |
| 工作椅 | 无 |
如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有0个、1个或2个附件。附件不再有从属于自己的附件。金明想买的东西很多，肯定会超过妈妈限定的N元。于是，他把每件物品规定了一个重要度，分为5等：用整数1~5表示，第5等最重要。他还从因特网上查到了每件物品的价格（都是10元的整数倍）。他希望在不超过N元（可以等于N元）的前提下，使每件物品的价格与重要度的乘积的总和最大。
设第j件物品的价格为v[j]，重要度为w[j]，共选中了k件物品，编号依次为j1，j2，……，jk，则所求的总和为：
v[j1]*w[j1]+v[j2]*w[j2]+ …+v[jk]*w[jk]。（其中*为乘号）
请你帮助金明设计一个满足要求的购物单。
【输入文件】
输入文件budget.in 的第1行，为两个正整数，用一个空格隔开：
N m （其中N（<32000）表示总钱数，m（<60）为希望购买物品的个数。）
从第2行到第m+1行，第j行给出了编号为j-1的物品的基本数据，每行有3个非负整数： v p q
（其中v表示该物品的价格（v<10000），p表示该物品的重要度（1~5），q表示该物品是主件还是附件。如果q=0，表示该物品为主件，如果q>0，表示该物品为附件，q是所属主件的编号）
【输出文件】
输出文件budget.out只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值（<200000）。
【输入样例】
1000 5
800 2 0
400 5 1
300 5 1
400 3 0
500 2 0
【输出样例】
2200
【问题分析】
这道题是一道典型的背包问题，比较麻烦的就是它还存在附件和主件之分。但这并不影响解题，由于附件最多两个，那么我们做一个对主，附件做个捆绑就行了。
（1） 标准算法
因为这道题是典型的背包问题，显然标准算法就是动态规划。由于我们要对主，附件做捆绑。由于题目没有直接给出每个主件对应的附件，所以还需要做一个预处理：另开两个数组q1，q2来分别记录对应的第i个主件的附件。那么对与附件不需要处理。而主件的花费就有4种情况了。( 下面用W表示花费)
W1=v[i] （只买主件）
W2=v[i]+v[q1[i]] （买主件和第一个附件）
W3=v[i]+v[q2[i]] （买主件和第二个附件）
W4=v[i]+v[q1[i]]+v[q2[i]] （买主件和那两个附件）
设计一个状态opt[i]表示花i元钱可买到的物品的价格个重要度最大值。边界条件是opt[0]=0但是为了区分花i元钱是否可买到物品我们把初始条件opt[0]:=1;这样opt[i]>0说明花i元可以买到物品。这样就不难设计出这个状态的转移方程来：
opt[i]=maxopt[i],opt[i-wj] ((i-wj>0) and (opt[i-wj]>0)) (0<j<=4)
显然题目的解就是opt[1]到opt[n]中的一个最大值。但在输出是要注意将解减1。
注：价格是10是整数倍所以读入数据是可以使n=n div 10,wi=wi div 10
【源代码】
program budget;
const
fin='budget.in';
fout='budget.out';
maxn=3200;
maxm=100;
var
n,m,ans:longint;
v,p,q1,q2,q:array[0..maxm] oflongint;
opt:array[0..maxn] of longint;
procedure init;
var
i,x:longint;
begin
assign(input,fin);
reset(input);
assign(output,fout);
rewrite(output);
readln(n,m);
n:=n div 10;
fillchar(q1,sizeof(q1),0);
fillchar(q2,sizeof(q2),0);
for i:=1 to m do
begin
readln(v[i],p[i],q[i]);
v[i]:=v[i] div 10;
q2[q[i]]:=q1[q[i]];
q1[q[i]]:=i;
end;
close(input);
end;
function max(x,y:longint):longint;
begin
if x>y then exit(x);
exit(y);
end;
procedure main;
var
i,j:longint;
begin
fillchar(opt,sizeof(opt),0);
opt[0]:=1;
for j:=1 to m do
for i:=n downto v[j] do
if q[j]=0 then
begin
if (i-v[j]>=0) and(opt[i-v[j]]>0) then
opt[i]:=max(opt[i],opt[i-v[j]]+v[j]*p[j]);
if (i-v[j]-v[q1[j]]>=0) and(opt[i-v[j]-v[q1[j]]]>0) then
opt[i]:=max(opt[i],opt[i-v[j]-v[q1[j]]]+v[j]*p[j]+v[q1[j]]*p[q1[j]]);
if (i-v[j]-v[q2[j]]>=0) and(opt[i-v[j]-v[q2[j]]]>0) then
以上是关于动态规划经典教程的主要内容，如果未能解决你的问题，请参考以下文章