本文将详细介绍动态规划法的基本原理和适用条件，并通过经典例题辅助读者理解动态规划法的思想、掌握动态规划法的使用。本文给出的例题包括：多段图问题、矩阵连乘问题、最长公共子序列问题。
算法原理
动态规划是一种解决多阶段决策问题的优化方法，把多阶段过程转化为一系列单阶段问题，利用各个阶段之间的关系逐个求解。与分治法类似，动态规划法也是将待求解的问题分解为若干个子问题（阶段），但分治法中各子问题相互独立，而动态规划法适用于子问题重叠的情况，也即各子问题包含公共的子子问题。与贪心法类似，动态规划法可将一个问题的解决方案视为一系列决策的结果，但动态规划可以处理不满足贪心准则的问题。
动态规划法所能解决的问题一般需要满足以下性质：
- 最优性原理：如果问题的最优解所包含的子问题的解也是最优的，就称该问题具有最优子结构，即满足最优性原理。
- 无后效性：某阶段的状态一旦确定，就不受这个状态以后决策的影响。也即，某状态以后的过程不会影响以前的状态，只与当前的状态有关。
- 有重叠子问题：子问题之间是不独立的，一个子问题在下一个阶段决策中可能被多次使用。该性质是不是动态规划法适用的必要性质，但若无该性质，则动态规划法与其它算法相比不具备优势。
动态规划法的步骤：
- 分析最优解的性质，并刻画其结构特征；
- 递归定义最优解；
- 以自底向上或自顶向下的记忆化方式计算出最优值；
- 根据计算最优值得到的信息构造问题的最优解。
多段图问题
题目描述
设图 G=(V,E) 是一个带权有向图，图中的顶点被划分成 k 个互不相交的子集 V_i，(2≤k≤n,1≤i≤k)，使得 E 中任意一条边 <u,v> 必有 u∈V_i，v∈V_j，(1≤i<k,1<j≤k)，则称图 G 为多段图，称 s∈V_1 为源点，t∈V_k 为汇点，V_1 和 V_k 分别只有一个顶点。多段图的最短路径问题即为求从源点到汇点的最小代价路径（顶点编号从 0 开始，默认顶点 0 为源点，顶点 |V|-1 为汇点）。
输入输出
输入：先输入顶点个数 V 和边数 E，接着 E 行输入 E 条边及边的权值 (u,v,w)。
输出：第一行输出最短路径（用→连接），第二行输出最短路径的长度。
向后处理
以下图所示带权有向图为例（记为 G），解释如何通过“向后处理”求解最短路径以及最短路径的长度。
n 个顶点依次编号为 0,1,...,n-1，设 d[i] = 源点 s 到顶点 i 的最短路径的长度，则有 d[j]=min{d[i]|∃<i,j>∈E}。具体做法：
- 将
d[0..n-1]置为INF，设当前段所有点的集合为Vcur，下一段所有点的集合为Vnext，源点s所在段的顶点的集合为Vs，汇点t所在段的顶点的集合为Vt，Vcur初始置为Vs，Vnext由Vcur和边相关信息推出； - 根据
Vcur中的每一个顶点i尝试去更新Vnext中的每一个顶点j对应的d[j]，即，若d[j]>d[i]+cost[i][j]，则d[j]=d[i]+cost[i][j]，并记录j的前驱pre[j]为i，否则，不作处理； Vcur=Vnext，Vnext通过Vcur和边相关信息推出；- 若
Vcur!=Vt，则重复步骤2和3，否则，程序结束，d[t]即为源点s到汇点t的最短路径的长度，pre记录了最短路径上每个顶点的前驱。
// 准备工作
#define INF (INT_MAX/2-1)
typedef vector<int> vi;
int V, E; // 点数 边数
struct edge { int to, w; }; // 边
vector<vector<edge>> es; // es[i] 以i为起始点的边的集合
vi d; // 各点到源点s的最短距离，初始化为INF
vi pre; // pre[i] 最短路径上顶点i的前驱，初始化为-1
int main() {
// 输入
cin >> V >> E;
es.resize(V), d.resize(V, INF), pre.resize(V, -1);
for (int i = 0, u, v, w; i < E; ++i) {
cin >> u >> v >> w;
es[u].push_back({v, w});
}
// 求解
mulSegGraph(0);
vi path = getPath(V-1);
// 输出
printf("%d", path[0]);
for (int i = 1; i < path.size(); ++i)cout << "->" << path[i];
printf("\n%d", d[t]);
}/**
* 求多段图问题
* @param s 源点
*/
void mulSegGraph(int s) {
queue<int> seg; // 段
seg.push(s), d[s] = 0; // 源点入队列，起点到起点的距离设为0
while (!seg.empty()) {
int i = seg.front();
seg.pop();
// 更新所有以i为起始点的边的终点到起点s的最短距离
for (auto &e: es[i]) {
if (d[e.to] > d[i] + e.w) {
d[e.to] = d[i] + e.w;
pre[e.to] = i;
seg.push(e.to);
}
}
}
}/**
* 求源点s到汇点t的最短路径
* @param t 汇点
* @return 最短路径
*/
vi getPath(int t) {
vector<int> path;
for (; t != -1; t = pre[t])path.push_back(t);
reverse(path.begin(), path.end());
return path;
}时间复杂度：O(E+K)，其中，E 表示多段图的边数，K 表示多段图的段数。
空间复杂度：O(V+E)，其中，V 为多段图的顶点数。
向前处理
向后处理即从源点 s 出发，向汇点 t 迈进，向前处理则是从汇点 t 倒推回源点 s，处理方法与向后处理类似。n 个顶点依次编号为 0,1,...n-1，设 d[i] = 顶点 i 到汇点 t 的最短路径的长度，则有 d[i]=min{d[j]|∃<i,j>∈E}。具体做法：
- 将
d[0..n-1]置为INF，设当前段所有点的集合为Vcur，上一段所有点的集合为Vpre，源点s所在段的顶点的集合为Vs，汇点t所在段的顶点的集合为Vt，Vcur初始置为Vt，Vpre由Vcur和边相关信息推出； - 根据
Vcur中的每一个顶点j尝试去更新Vpre中的每一个顶点i对应的d[i]，即，若d[i] > d[j] + cost[i][j]，则d[i] = d[j] + cost[i][j]，并记录i的后继nex[i]为j，否则，不作处理； Vcur = Vpre，Vpre通过Vcur和边相关信息推出；- 若
Vcur != Vs，则重复步骤2和3，否则，程序结束，d[s]即为源点s到汇点t的最短路径的长度，nex记录了最短路径上每个顶点的后继。
// 准备工作
#define INF (INT_MAX/2-1)
typedef vector<int> vi;
int V, E; // 点数 边数
struct edge { int from, w; }; // 边
vector<vector<edge>> es; // es[i] 以i为终点的边的集合
vi d; // 各点到汇点t的最短距离，初始化为INF
vi nex; // nex[i] 最短路径上顶点i的后继，初始化为-1
int main() {
// 输入
cin >> V >> E;
es.resize(V), d.resize(V, INF), nex.resize(V, -1);
for (int i = 0, u, v, w; i < E; ++i) {
cin >> u >> v >> w;
es[v].push_back({u, w});
}
// 求解
mulSegGraph(V-1);
vi path = getPath(0);
// 输出
cout << path[0];
for (int i = 1; i < path.size(); ++i)cout << "->" << path[i];
cout << '\n' << d[s];
}/**
* 求多段图问题
* @param t 汇点
*/
void mulSegGraph(int t) {
queue<int> seg; // 段
seg.push(t), d[t] = 0; // 汇点t入队列，汇点t到汇点t的距离设为0
while (!seg.empty()) {
int i = seg.front();
seg.pop();
// 更新所有以i为终点的边的起始点到汇点t的最短距离
for (auto &e: es[i]) {
if (d[e.from] > d[i] + e.w) {
d[e.from] = d[i] + e.w;
nex[e.from] = i;
seg.push(e.from);
}
}
}
}/**
* 求源点s到汇点t的最短路径
* @param s 源点
* @return 最短路径
*/
vi getPath(int s) {
vi path;
for (; s != -1; s = nex[s])path.push_back(s);
return path;
}时间复杂度：O(E+K)，其中，E 表示多段图的边数，K 表示多段图的段数。
空间复杂度：O(V+E)，其中，V 为多段图的顶点数。
优化处理
观察向前处理和向后处理两种方案的输出结果发现，对于同一个多段图，二者给出的最短路径并不相同，但最短路径的长度是相同的。这是因为，当前多段图存在多条最短路径，而两个方案中存储最短路径的数组均为一维数组，只能记录一条最短路径。
为此，以向后处理为例，修改记录最短路径的数组 pre 为二维数组，pre[i] 用于记录每一条最短路径上节点 i 的前驱，即 pre[i] 为节点 i 的前驱的集合。在向后处理的的基础上做如下修改（与向前处理类似）。
...
vector<set<int>> pre; // pre[i] 最短路径上顶点i的前驱的集合
...
int main() {
...
pre.resize(V), pre[0].insert(-1);
...
// 读取最短路径
vector<vi> paths;
vi path;
getPaths(t, paths, path);
// 输出
for (const auto &ph: paths) {
cout << ph[0];
for (int i = 1; i < ph.size(); ++i)cout << "->" << ph[i];
}
...
}void mulSegGraph(int s) {
...
while (!seg.empty()) {
...
for (auto &e: es[i]) {
if (d[e.to] >= d[i] + e.w) {
// 记录多条路径
if (d[e.to] > d[i] + e.w) {
// 找到到e.to更短的路径则清除e.to原来记录的前驱
pre[e.to].clear();
pre[e.to].insert(i);
d[e.to] = d[i] + e.w;
}
// 找到与目前到e.to的最短路径长度相同的路径则记录
else pre[e.to].insert(i);
seg.push(e.to);
}
}
}
}/**
* 求源点s到汇点t的所有最短路径
* @param t 汇点
* @param paths 所有路径
* @param path 已搜索到的路径
*/
void getPaths(int t, vector<vi> &paths, vi path) {
if (t == -1) { // 当前最短路径搜索完毕
reverse(path.begin(), path.end());
paths.push_back(path);
return;
} else path.push_back(t);
for (auto &p: pre[t])getPaths(p, paths, path);
}时间复杂度：O(E+MK)，其中，E 表示多段图的边数，M 表示最短路径的数目，K 表示多段图的段数。
空间复杂度：O(V+E)，其中，V 为多段图的顶点数。
矩阵连乘问题
题目描述
给定 n 个矩阵 A_0,A_1,…,A_{n-1}，其中 A_i 的维数为 p_i × p_{i+1}，并且 A_i 与 A_{i+1} 是可乘的。考察这 n 个矩阵的连乘积 A_0 × A_1 ×…× A_{n-1}，由于矩阵乘法满足结合律，所以计算矩阵的连乘可有许多不同的计算次序。矩阵连乘问题是确定计算矩阵连乘积的计算次序，使得按照这一次序计算矩阵连乘积，需要的“数乘”次数最少。
输入输出
输入：第一行输入 n 的值，第二行输入 n 个矩阵的维数 p_i。
输出：最少数乘次数以及对应的计算次序。
基础实现
设 m[i][j]=A_i...A_j 的最小数乘次数 (0≤i≤j≤n-1)，p[i] = 矩阵 A_i 的行数，p[i+1] = 矩阵 A_i 的列数 = 矩阵 A_{i+1} 的行数 (0≤i≤n-1)，则有 m[i][j] = min{m[i][k] + m[k+1][j] + p[i] × p[k+1] × p[j+1] | i<k<j}，当 i=j 时，有 m[i][j]=0，也即 m[i][i]=0。为了后续输出对应的计算次序，增加数组 b 用于记录划分点，b[i][j]=A_i...A_j 的划分点，划分点属于左侧。
typedef vector<int> vi;
int N; // 矩阵数
vi p; // p[i] 矩阵Ai的行数，同时也是举证Ai+1的列数
vector<vi> m; // m[i][j] Ai...Aj的最小数乘次数
vector<vi> b; // b[i][j] Ai...Aj的划分点，划分点属于左侧
int main() {
// 输入
cin >> N;
p.resize(N + 1, 0), m.resize(N, vi(N, 0)), b.resize(N, vi(N, -1));
for (int i = 0; i <= N; ++i)cin >> p[i];
// 求解
minNumMul();
// 输出
cout << m[0][N - 1] << endl;
bracket(0, N - 1);
}/**
* 计算A0A1...An-1的最少数乘次数
*/
void minNumMul() {
int i, j, k;
// 求k个矩阵相乘时的最少数乘次数
for (k = 2; k <= N; k++)
// 求每个长度为k子序列(i,j)的子序列的划分点（划分点属于左侧）
for (i = 0; i < N - k + 1; i++) {
j = i + k - 1;
// 以i为划分点赋初值，省略+m[i][i]，因为m[i][i]=0
m[i][j] = m[i + 1][j] + p[i] * p[i + 1] * p[j + 1];
b[i][j] = i;
// 尝试每个可能的划分
for (int r = i + 1, t; r < j; r++) {
t = m[i][r] + m[r + 1][j] + p[i] * p[r + 1] * p[j + 1];
if (t < m[i][j]) {
m[i][j] = t; // 记录数乘数
b[i][j] = r; // 记录划分点
}
}
}
}/**
* 显示Ai...Aj数乘次数最少时对应的计算次序
*/
void bracket(int i, int j) {
cout << "(";
if(i == b[i][j])printf("A%d", i); // 划分点b[i][j]左侧没有划分点
else bracket(i, b[i][j]);
if (b[i][j] + 1 == j) // 划分点b[i][j]右侧没有划分点
for (int k = b[i][j] + 1; k <= j; ++k) printf("A%d", k);
else bracket(b[i][j] + 1, j);
cout << ")";
}时间复杂度：O(n^3)。
空间复杂度：O(n^2)。
优化处理
观察 minNumMul() 函数发现，二维数组 m 只利用了下标 i≤j 的空间，二维数组 b 只利用了下标 i<j 的空间，而且二者大小均为 N×N 。因此，为了节约空间，可以将两个二维数组合并，具体做法就是用 m[j][i] 直接替换掉原来的 b[i][j]，其中 i<j。在基础实现的基础上做如下修改：
void minNumMul() {
...
for (k = 2; k <= N; k++)
for (i = 0; i < N - k + 1; i++) {
...
// b[i][j] = i;
m[j][i] = i;
for (int r = i + 1, t; r < j; r++) {
...
if (t < m[i][j]) {
...
// b[i][j] = r;
m[j][i] = r;
}
}
}
}void bracket(int i, int j) {
cout << "(";
if (i == m[j][i])printf("A%d", i); // 划分点b[i][j]左侧没有划分点
else bracket(i, m[j][i]);
if (m[j][i] + 1 == j) // 划分点b[i][j]右侧没有划分点
for (int k = m[j][i] + 1; k <= j; ++k) printf("A%d", k);
else bracket(m[j][i] + 1, j);
cout << ")";
}时间复杂度：O(n^3)。
空间复杂度：O(n^2)。
最长公共子序列问题
题目描述
给定两个序列 X={x_1,x_2,…,x_m} 和 Y={y_1,y_2,…,y_n}，找出 X 和 Y 的最长公共子序列。
输入输出
输入：第一行输入序列 X，第二行输入序列 Y。
输出：X 和 Y 的最长公共子序列和最长公共子序列的长度
基础实现
设 L[i][j] 为 x_1...x_i 与 y_1...y_j 的最长公共子序列（设为 Z ）的长度，则有
- ①
i=0或j=0时，l[i][j]=0； - ② 当
Z末位不为x_i不为y_j时，L[i][j]= L[i-1][j-1]； - ③ 当
Z末位不为x_i为y_j时，L[i][j]= L[i-1][j]； - ④ 当
Z末位为x_i不为y_j时，L[i][j]= L[i][j-1]； - ⑤ 当
Z末位为x_i且为y_j时（此时x_i与y_j必相等），L[i][j]= L[i-1][j-1]+1。
综上，若 x_i=y_j，L[i][j]= L[i-1][j-1]+1，否则 L[i][j]=max(L[i-1][j-1], L[i-1][j], L[i][j-1])。
需要注意，③中 L[i-1][j] 实际表示 Z 末位不为 x_i 的情况，比②中前提表示范围要大，但包含了③中前提表示范围，④和⑤中也是类似。虽然如此，但并不影响结果的正确性。①到⑤的前提表示范围可以覆盖所有情况，③④⑤实际表示范围均包含了各自前提表示范围，只不过各自均考虑了一些前提以外的情况，这些情况仍在整体待考虑的范围之内，由于求“最长”，即使重复考虑了某些情况，也并不影响最值。
以字符串 abad 和 baade 为例，构造二维数组 L 如下图所示。
应用上述规则，通过对二维数组 L 反向搜索，便可以得到最长公共子序列。为了在反向搜索时更加方便地直到 L[i][j] 究竟来自 L[i-1][j]、L[i][j-1]、L[i-1][j-1] 中的哪一个，可以增设数组 W[i][j]，在构造二维数组L的同时对 L[i][j] 来自哪里进行记录。
// L[i][j]: x1x2...xi与y1y2...yj的最长公共子序列的长度
vector<vector<int>> L;
// W[i][j]: L[i][j]的值是通过l[i-1][j]、L[i][j-1]、L[i-1][j-1]中的哪一个得到的
// 用于还原最长公共子序列
vector<vector<int>> W;
// W[i][j]的三个值，分别对应l[i-1][j-1]、L[i-1][j]、L[i][j-1]
int LU = 1, LEFT = 2, UP = 3;
string X, Y; // 字符串
int main() {
// 输入
cin >> X >> Y;
int m = X.length(), n = Y.length();
L.resize(m + 1, vector<int>(n + 1, 0));
W.resize(m + 1, vector<int>(n + 1, 0));
// 求解
lonComSub();
string s = sub();
// 输出
cout << s << '\n' << L[m][n];
}/**
* 求最长公共子序列即其长度，也即填充l和w
*/
void lonComSub() {
int i, j;
for (i = 0; i < X.length(); ++i) {
for (j = 0; j < Y.length(); ++j) {
if (X[i] == Y[j]) {
L[i + 1][j + 1] = L[i][j] + 1;
W[i + 1][j + 1] = LU; // (i,j)是左上方来的
} else if (L[i + 1][j] > L[i][j + 1]) {
L[i + 1][j + 1] = L[i + 1][j];
W[i + 1][j + 1] = LEFT; // (i,j)是从左边来的
} else {
L[i + 1][j + 1] = L[i][j + 1];
W[i + 1][j + 1] = UP; // (i,j)是从上边来的
}
}
}
}/**
* 以字符串的形式返回最长公共子序列
*/
string sub() {
string s;
int i = X.length(), j = Y.length();
while (i > 0 && j > 0) {
if (W[i][j] == LU) { // 从左上来的
s = X[i - 1] + s;
i--, j--;
} else if (W[i][j] == LEFT) j--; // 从左边来的
else i--; // 从上面来的
}
return s;
}时间复杂度：O(mn)。
空间复杂度：O(mn)。
优化处理
观察基础实现的测试结果不难发现，当 X 和 Y 存在多个最长公共子序列时，程序只输出了其中一个，为此，需要修改获取最长公共子序列的函数，即 sub() 函数。在基础实现的基础上做如下修改：
int main() {
// 初始化
cin >> X >> Y;
int m = X.length(), n = Y.length();
L.resize(m + 1, vector<int>(n + 1, 0));
W.resize(m + 1, vector<int>(n + 1, 0));
// 求解
lonComSub();
vector<string> ss;
string s;
sub(m, n, ss, s);
// 输出
for (auto &it: ss)cout << it << endl;
cout << L[m][n];
}/**
* 获取最长公共子序列
* @param i,j 坐标
* @param ss 所有公共子序列
* @param s 目前已搜索到的最长公共子序列
*/
void sub(int i, int j, vector<string> &ss, string s) {
if (i < 1 || j < 1) { // 找到一条路径
ss.push_back(s);
return;
}
if (X[i - 1] == Y[j - 1]) // 左上来的
sub(i - 1, j - 1, ss, X[i - 1] + s);
else if (L[i][j - 1] > L[i - 1][j]) // 左边来的
sub(i, j - 1, ss, s);
else if (L[i][j - 1] < L[i - 1][j]) // 上面来的
sub(i - 1, j, ss, s);
else sub(i, j - 1, ss, s), sub(i - 1, j, ss, s); // 左和上均可能
}此外，用于记录 L[i][j] 来自哪的二维数组 W 并非是必须的，二维数组 W 存储的信息可以从 L、X、Y 中推导出来，如果从节省空间的角度考虑，可以撤去二维数组 W（优化后用于获取所有最长公共子序列的函数 sub() 便没有用到 W）。
当不需要输出具体的最长公共子序列，而只需要求最长公共子序列的长度时，可用一滑动数组 v 替换掉数组 L。主要代码实现如下：
int main() {
// 输入
cin >> X >> Y;
// 求解并输出
cout << lonComSubSimply();
}/**
* 使用滑动数组求最长公共子序列长度
* @return 最长公共子序列长度
*/
int lonComSubSimply() {
// 滑动数组v记录当前行，用当前行依次更新下一行的每个单元，当前行初始为v[0...n]=0
int m = X.length(), n = Y.length();
vector<int> v(n + 1, 0);
int lu, left, up; // 下一行单元j的左上、左边、上面单元
for (int i = 0; i < m; ++i) {
lu = left = v[0]; // 下一行单元j的左上和左边初始为v[0]，即0
up = v[1]; // 上边为v[1]
for (int j = 0; j < n; ++j) {
// 更新v
if (X[i] == Y[j])v[j + 1] = lu + 1;
else if (left > up) v[j + 1] = left;
else v[j + 1] = up;
// 更新游标
lu = up, up = v[j + 2], left = v[j + 1];
}
}
return v[n];
}时间复杂度：O(mn)。
空间复杂度：O(n)。
经验总结
动态规划法适用于子问题重叠的情况，即适合解决冗余，并且可以处理不满足贪心准则的问题，一般而言，采用动态规划法解决问题只需要多项式时间复杂度。但是，动态规划法没有统一的标准模型，需要根据问题具有的性质来进行处理，因此，不同问题得到的模型可能不太一样。并且，动态规划法需要存储在求解过程中得到的各种状态信息，因而需要占用较大的存储空间，空间复杂度较之于其它算法较高。动态规划法实质上是一种以空间换时间的技术。
虽然动态规划没有统一的标准模型，但是仍有一些固定的套路。动态规划问题通常有一个 dp 数组，用来表示所有状态即对应的值，于是，求解动态规划问题就转为定义 dp 数组和填充 dp 数组。
定义 dp 数组需要考虑维度和值。通常 dp 数组维度与表示一个状态所需变量个数相同，维度应该尽可能少，dp 数组的值通常为题目所求，如最大值、最小值、计数。
填充 dp 数组（假设二维，方便后面描述）需要考虑状态转移方程和边界值。得出状态转移方程前，需要分类讨论，即考虑在一般情况下（此时先不要管特殊情况，如边界值）的某个状态 dp[i][j]，可以通过哪些状态转换而来，分类依据通常可以考虑“包含和不包含”、“包含多少”、“方向”等，分类需要做到不遗漏、不重复（最值问题一般可以重复、计数问题一般不能重复），每种情况均需对应一个 dp[x][y]，最后根据 dp[i][j] 与 dp[x][y] 的关系写出状态转移方程。边界值需要视情况而定，但通常用下标 0 来存放（一维的 dp[0]、二维的 dp[0][i] 和 dp[i][0]、…），因而填充 dp 数组时从下标 1 开始。
对于 dp 数组，以二维为例，若计算第 i 行时，只用到 dp 数组的第 i-1 行和 i 行的值，则该二维数组可去掉第一维，转为一维数组。一般而言，填充 dp 数组需要用到两层循环，计算 dp[i][j]，i 从小到大，j 从小到大，转换之后，j 可能需要改为从大到小，这从状态转移方程很容易看出需不需要改变方向。
此外，对于不同类型的动态规划问题，也有一些针对性的“经验”。对于线性 DP，如最长公共子序列问题，划分时通常考虑“前多少”。对于区间 DP，如矩阵连乘问题，填充 dp 数组时，第一层循环通常用于枚举长度。对于计数类 DP，如整数划分问题，分类讨论时，必须做到各情况之间没有交集。对于树形 DP，如没有上司的舞会问题，通常使用递归。背包问题也是一类经典的DP问题，整数划分问题便可转为完全背包问题求解。
由于动态规划问题没有统一的标准模型，因此求解问题时更依赖于“经验”，所以更需要多看多练多总结，不断地增加“经验”，这样，在处理动态规划问题时才不会无从下手。
END
文章文档：公众号 字节幺零二四 回复关键字可获取本文文档。
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。