动态规划(一)
例题
数字三角形
5
例题一、数字三角形(POJ1163)
在上面的数字三角形中寻找一条从顶部到底边的路径，使得
路径上所经过的数字之和最大。路径上的每一步都只能往左下或
右下走。只需要求出这个最大和即可，不必给出具体路径。
三角形的行数大于1小于等于100，数字为 0 - 99
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
6
输入格式：
5 //三角形行数。下面是三角形
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
要求输出最大和
7
解题思路：
用二维数组存放数字三角形。
D( r, j) : 第r行第 j 个数字(r,j从1开始算)
MaxSum(r, j) : 从D(r,j)到底边的各条路径中，
最佳路径的数字之和。
问题：求 MaxSum(1,1)
典型的递归问题。
D(r, j)出发，下一步只能走D(r+1,j)或者D(r+1, j+1)。故对于N行的三角形：
if ( r == N)
MaxSum(r,j) = D(r,j)
else
MaxSum( r, j) = Max{ MaxSum(r＋1,j), MaxSum(r+1,j+1) }
- D(r,j)
8
#include <iostream>
#include <algorithm>
#define MAX 101
using namespace std;
int D[MAX][MAX];
int n;
int MaxSum(int i, int j){
if(i==n)
return D[i][j];
int x = MaxSum(i+1,j);
int y = MaxSum(i+1,j+1);
return max(x,y)+D[i][j];
}
数字三角形的递归程序:
int main(){
int i,j;
cin >> n;
for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
cin >> D[i][j];
cout << MaxSum(1,1) << endl;
}
9
为什么超时？
回答：重复计算
71
31 81
81 12 01
21 73 43 41
41 54 26 64 51
如果采用递规的方法，深度遍历每条路径，存在大
量重复计算。则时间复杂度为 2
n
,对于 n = 100 行，
肯定超时。
10
如果每算出一个MaxSum(r,j)就保存起来，下次用
到其值的时候直接取用，则可免去重复计算。那么
可以用O(n2
)时间完成计算。因为三角形的数字总
数是 n(n+1)/2
改进
11
数字三角形的记忆递归型动归程序：
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 101
int D[MAX][MAX]; int n;
int maxSum[MAX][MAX];
int MaxSum(int i, int j){
if( maxSum[i][j] != -1 )
return maxSum[i][j];
if(i==n)
maxSum[i][j] = D[i][j];
else {
int x = MaxSum(i+1,j);
int y = MaxSum(i+1,j+1);
maxSum[i][j] = max(x,y)+
D[i][j];
}
return maxSum[i][j];
}
int main(){
int i,j;
cin >> n;
for(i=1;i<=n;i++)
for(j=1;j<=i;j++) {
cin >> D[i][j];
maxSum[i][j] = -1;
}
cout << MaxSum(1,1) << endl;
}
12
4
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
递归转成递推
5 2 6 5
13
4
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
递归转成递推
5 2 6 5
7
14
4
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
递归转成递推
5 2 6 5
7 12
15
4
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
递归转成递推
5 2 6 5
7 12 10
16
4
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
递归转成递推
5 2 6 5
7 12 10 10
17
4
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
递归转成递推
5 2 6 5
7 12 10 10
20
18
4
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
递归转成递推
5 2 6 5
7 12 10 10
20 13
19
4
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
递归转成递推
5 2 6 5
7 12 10 10
20 13 10
20
4
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
递归转成递推
5 2 6 5
7 12 10 10
20 13 10
23 21
30
21
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 101
int D[MAX][MAX]; int n;
int maxSum[MAX][MAX];
int main() {
int i,j;
cin >> n;
for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
cin >> D[i][j];
for( int i = 1;i <= n; ++ i )
maxSum[n][i] = D[n][i];
for( int i = n-1; i>= 1; --i )
for( int j = 1; j <= i; ++j )
maxSum[i][j] =
max(maxSum[i+1][j],maxSum[i+1][j+1]) + D[i][j]
cout << maxSum[1][1] << endl;
}
22
空间优化
4
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5 5 2 6 5
没必要用二维maxSum数组存储每一个MaxSum(r,j),只要从底层一行行向上
递推，那么只要一维数组maxSum[100]即可,即只要存储一行的MaxSum值就
可以。
23
空间优化
7
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5 5 2 6 5
没必要用二维maxSum数组存储每一个MaxSum(r,j),只要从底层一行行向上
递推，那么只要一维数组maxSum[100]即可,即只要存储一行的MaxSum值就
可以。
24
空间优化
7
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5 12 2 6 5
没必要用二维maxSum数组存储每一个MaxSum(r,j),只要从底层一行行向上
递推，那么只要一维数组maxSum[100]即可,即只要存储一行的MaxSum值就
可以。
25
空间优化
7
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5 12 10 6 5
没必要用二维maxSum数组存储每一个MaxSum(r,j),只要从底层一行行向上
递推，那么只要一维数组maxSum[100]即可,即只要存储一行的MaxSum值就
可以。
26
空间优化
7
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5 12 10 10 5
没必要用二维maxSum数组存储每一个MaxSum(r,j),只要从底层一行行向上
递推，那么只要一维数组maxSum[100]即可,即只要存储一行的MaxSum值就
可以。
27
空间优化
20
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5 12 10 10 5
没必要用二维maxSum数组存储每一个MaxSum(r,j),只要从底层一行行向上
递推，那么只要一维数组maxSum[100]即可,即只要存储一行的MaxSum值就
可以。
28
空间优化
20
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5 13 10 10 5
没必要用二维maxSum数组存储每一个MaxSum(r,j),只要从底层一行行向上
递推，那么只要一维数组maxSum[100]即可,即只要存储一行的MaxSum值就
可以。
29
空间优化
进一步考虑，连maxSum数组都可以不要，直接用D的
第n行替代maxSum即可。
节省空间，时间复杂度不变
30
#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 101
int D[MAX][MAX];
int n; int * maxSum;
int main(){
int i,j;
cin >> n;
for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
cin >> D[i][j];
maxSum = D[n]; //maxSum指向第n行
for( int i = n-1; i>= 1; --i )
for( int j = 1; j <= i; ++j )
maxSum[j] = max(maxSum[j],maxSum[j+1]) + D[i][j];
cout << maxSum[1] << endl;
}
空间优化
动规解题的一般思路
信息科学技术学院
加拿大班芙国家公园
32
递归到动规的一般转化方法
递归函数有n个参数，就定义一个n维的数组，数组
的下标是递归函数参数的取值范围，数组元素的值
是递归函数的返回值，这样就可以从边界值开始，
逐步填充数组，相当于计算递归函数值的逆过程。
33
动规解题的一般思路
- 将原问题分解为子问题
把原问题分解为若干个子问题，子问题和原问题形式相同
或类似，只不过规模变小了。子问题都解决，原问题即解
决(数字三角形例）。
子问题的解一旦求出就会被保存，所以每个子问题只需求
解一次。
34
动规解题的一般思路 - 确定状态
在用动态规划解题时，我们往往将和子问题相
关的各个变量的一组取值，称之为一个“状
态”。一个“状态”对应于一个或多个子问题，
所谓某个“状态”下的“值”，就是这个“状
态”所对应的子问题的解。
35
动规解题的一般思路 - 确定状态
所有“状态”的集合，构成问题的“状态空间”。“状态
空间”的大小，与用动态规划解决问题的时间复杂度直接相关。
在数字三角形的例子里，一共有N×(N+1)/2个数字，所以这个
问题的状态空间里一共就有N×(N+1)/2个状态。
整个问题的时间复杂度是状态数目乘以计算每个状态所需
时间。
在数字三角形里每个“状态”只需要经过一次，且在每个
状态上作计算所花的时间都是和N无关的常数。
36
动规解题的一般思路 - 确定状态
用动态规划解题，经常碰到的情况是，K个整型变量能
构成一个状态（如数字三角形中的行号和列号这两个变量
构成“状态”）。如果这K个整型变量的取值范围分别是
N1, N2, ……Nk，那么，我们就可以用一个K维的数组
array[N1] [N2]……[Nk]来存储各个状态的“值”。这个
“值”未必就是一个整数或浮点数，可能是需要一个结构
才能表示的，那么array就可以是一个结构数组。一个
“状态”下的“值”通常会是一个或多个子问题的解。
37
动规解题的一般思路 - 确定一些初始状态（边界状态）的值
以“数字三角形”为例，初始状态就是底边数字，值
就是底边数字值。
38
动规解题的一般思路 - 确定状态转移方程
定义出什么是“状态”，以及在该 “状态”下的“值”后，就要
找出不同的状态之间如何迁移――即如何从一个或多个“值”已知的
“状态”，求出另一个“状态”的“值”(“人人为我”递推型)。状
态的迁移可以用递推公式表示，此递推公式也可被称作“状态转移方
程”。
数字三角形的状态转移方程:
39
能用动规解决的问题的特点
- 问题具有最优子结构性质。如果问题的最优解所包含的
子问题的解也是最优的，我们就称该问题具有最优子结
构性质。 - 无后效性。当前的若干个状态值一旦确定，则此后过程
的演变就只和这若干个状态的值有关，和之前是采取哪
种手段或经过哪条路径演变到当前的这若干个状态，没
有关系。
例题
最长上升子序列
41
例题二：最长上升子序列(百练2757)
问题描述
一个数的序列ai，当a1 < a2 < … < aS的时候，我们称这个序
列是上升的。对于给定的一个序列(a1
, a2
, …, aN)，我们可以得到
一些上升的子序列(ai1, ai2, …, aiK)，这里1 <= i1 < i2 < … < iK
<= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子
序列，如(1, 7), (3, 4, 8)等等。这些子序列中最长的长度是4，比
如子序列(1, 3, 5, 8).
你的任务，就是对于给定的序列，求出最长上升子序列的长度。
42
输入数据
输入的第一行是序列的长度N (1 <= N <= 1000)。第二行给
出序列中的N个整数，这些整数的取值范围都在0到10000。
输出要求
最长上升子序列的长度。
输入样例
7
1 7 3 5 9 4 8
输出样例
4
43
解题思路
1.找子问题
“求序列的前n个元素的最长上升子序列的长度”是个
子问题，但这样分解子问题，不具有“无后效性”
假设F(n) = x,但可能有多个序列满足F(n) = x。有的序
列的最后一个元素比 an+1小，则加上an+1就能形成更长上
升子序列；有的序列最后一个元素不比an+1小……以后的事
情受如何达到状态n的影响，不符合“无后效性”
44
解题思路
1.找子问题
“求以ak（k=1, 2, 3…N）为终点的最长上升子序列的
长度”
一个上升子序列中最右边的那个数，称为该子序列的
“终点”。
虽然这个子问题和原问题形式上并不完全一样，但
是只要这N个子问题都解决了，那么这N个子问题的解中，
最大的那个就是整个问题的解。
45
- 确定状态：
子问题只和一个变量-- 数字的位置相关。因此序列中数的
位置k 就是“状态”，而状态 k 对应的“值”，就是以ak做为
“终点”的最长上升子序列的长度。
状态一共有N个。
46 - 找出状态转移方程：
maxLen (k)表示以ak做为“终点”的
最长上升子序列的长度那么：
初始状态：maxLen (1) = 1
maxLen (k) = max { maxLen (i)：1<=i < k 且 ai < ak且 k≠1 } + 1
若找不到这样的i,则maxLen(k) = 1
maxLen(k)的值，就是在ak左边，“终点”数值小于ak ，且长度
最大的那个上升子序列的长度再加1。因为ak左边任何“终点”小
于ak的子序列，加上ak后就能形成一个更长的上升子序列。
47
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN =1010;
int a[MAXN]; int maxLen[MAXN];
int main() {
int N; cin >> N;
for( int i = 1;i <= N;++i) {
cin >> a[i]; maxLen[i] = 1;
}
for( int i = 2; i <= N; ++i) {
//每次求以第i个数为终点的最长上升子序列的长度
for( int j = 1; j < i; ++j)
//察看以第j个数为终点的最长上升子序列
if( a[i] > a[j] )
maxLen[i] = max(maxLen[i],maxLen[j]+1);
}
cout << * max_element(maxLen+1,maxLen + N + 1 );
return 0;
} //时间复杂度O(N2)
“人人为我”递推型动归程序
48
动归的常用两种形式
1）递归型
优点：直观，容易编写
缺点：可能会因递归层数太深导致爆栈，函数调用带来额外
时间开销。无法使用滚动数组节省空间。总体来说，比递推型
慢。
1）递推型
效率高，有可能使用滚动数组节省空间
例题
最长公共子序列
信息科学技术学院
荷兰阿姆斯特丹库肯霍立夫公园
50
例三、公共子序列（POJ1458)
给出两个字符串，求出这样的一
个最长的公共子序列的长度：子序列
中的每个字符都能在两个原串中找到，
而且每个字符的先后顺序和原串中的
先后顺序一致。
51
最长公共子序列
Sample Input
abcfbc abfcab
programming contest
abcd mnp
Sample Output 42
0
52
输入两个串s1,s2,
设MaxLen(i,j)表示:
s1的左边i个字符形成的子串，与s2左边的j个
字符形成的子串的最长公共子序列的长度(i,j从0
开始算）
MaxLen(i,j) 就是本题的“状态”
假定 len1 = strlen(s1),len2 = strlen(s2）
那么题目就是要求 MaxLen(len1,len2)
最
长
公
共
子
序
列
53
显然：
MaxLen(n,0) = 0 ( n= 0…len1）
MaxLen(0,n) = 0 ( n=0…len2）
递推公式：
if ( s1[i-1] == s2[j-1] ) //s1的最左边字符是s1[0]
MaxLen(i,j) = MaxLen(i-1,j-1) + 1;
else
MaxLen(i,j) = Max(MaxLen(i,j-1),MaxLen(i-1,j) );
时间复杂度O(mn) m,n是两个字串长度
最
长
公
共
子
序
列
54
S1
s1[i-1]
S2
s2[j-1]
S1i-1
S2j-1
S1长度为 i
S2长度为 j
S1[i-1]!= s2[j-1]时，MaxLen(S1,S2)不会比MaxLen(S1,S2j-1
)
和MaxLen(S1i-1
,S2)两者之中任何一个小，也不会比两者都大。
55
#include <iostream>
#include <cstring>
using namespace std;
char sz1[1000];
char sz2[1000];
int maxLen[1000][1000];
int main() {
while( cin >> sz1 >> sz2 ) {
int length1 = strlen( sz1);
int length2 = strlen( sz2);
int nTmp;
int i,j;
for( i = 0;i <= length1; i ++ )
maxLen[i][0] = 0;
for( j = 0;j <= length2; j ++ )
maxLen[0][j] = 0;
56
for( i = 1;i <= length1;i ++ ) {
for( j = 1; j <= length2; j ++ ) {
if( sz1[i-1] == sz2[j-1] )
maxLen[i][j] = maxLen[i-1][j-1] + 1;
else
maxLen[i][j] = max(maxLen[i][j-1],
maxLen[i-1][j]);
}
}
cout << maxLen[length1][length2] << endl;
}
return 0;
}
57
活学活用
掌握递归和动态规划的思想，解决问题时灵活应用
例题
最佳加法表达式
59
有一个由1…9组成的数字串.问如果将m个加
号插入到这个数字串中,在各种可能形成的
表达式中，值最小的那个表达式的值是多少
例四、最佳加法表达式
60
假定数字串长度是n，添完加号后,表达式的最后
一个加号添加在第 i 个数字后面，那么整个表达
式的最小值，就等于在前 i 个数字中插入 m – 1
个加号所能形成的最小值，加上第 i + 1到第 n
个数字所组成的数的值（i从1开始算）。
解题思路
61
设V(m,n)表示在n个数字中插入m个加号所能形成
的表达式最小值，那么：
if m = 0
V(m,n) = n个数字构成的整数
else if n < m + 1
V(m,n) = ∞
else
V(m,n) = Min{ V(m-1,i) + Num(i+1,n) } ( i = m … n-1)
Num(i,j)表示从第i个数字到第j个数字所组成的数。数字编号从1开始算。此操
作复杂度是O(j-i+1)，可以预处理后存起来。
总时间复杂度：O(mn2
) .
解题思路
62
总时间复杂度：O(mn2
) .
若 n 比较大，long long 不够存放运算过程中的整数，则需要使用高精度计算
（用数组存放大整数，模拟列竖式做加法），复杂度为O(mn3
)
