算法竞赛专题解析（14）：DP应用--区间DP
本系列文章将于2021年整理出版，书名《算法竞赛专题解析》。
前驱教材是：《算法竞赛入门到进阶》(京东 当当 ) 清华大学出版社。
如有建议，请联系：（1）QQ 群，567554289；（2）作者QQ，15512356
1.概念和模板代码
区间DP[1]是常见的DP应用场景。
经典例子是“石子合并”问题，用这个例子解释区间DP的概念，并给出两种模板代码。
石子合并
题目描述：有n堆石子排成一排，每堆石子有一定的数量。将n堆石子并成为一堆，每次只能合并相邻的两堆石子，合并的花费为这两堆石子的总数。经过n-1次合并后成为一堆，求总的最小花费。
输入：第一行是整数n，表示有n堆石子。第二行有n个数，分别表示这n堆石子的数目。
输出：总的最小花费。
输入样例：
3
2 4 5
输出样例：
17
提示：样例的计算过程是：第一次合并2+4=6；第二次合并6+5=11；总花费6+11=17。
定义\(dp[i][j]\)为合并第i堆到第j堆的最小花费。状态转移方程是：
\(dp[i][j] = min\{dp[i][k] + dp[k + 1][j] + w[i][j]\}\) \(i ≤ k <j\)
\(dp[1][n]\)就是答案。方程中的\(w[i][j]\)表示从第\(i\)堆到第\(j\)堆的石子总数。
按自顶向下的思路分析状态转移方程，很容易理解。计算大区间\([i, j]\)的最优值时，合并它的两个子区间\([i, k]\)和\([k+1, j]\)，对所有可能的合并（\(i ≤ k < j\)，即\(k\)在\(i、j\)之间滑动），返回那个最优的合并。子区间再继续分解为更小的区间，最小的区间\([i, i+1]\)只包含两堆石子。
编程用自底向上递推的方法，先在小区间进行DP得到最优解，然后再逐步合并小区间为大区间。下面给出求\(dp[i][j]\)的代码，其中包含\(i、j、k\)的3层循环，时间复杂度\(O(n^3)\)。第一个循环\(j\)是区间终点，第2个循环\(i\)是区间起点，第3个循环\(k\)在区间内滑动。注意，起点\(i\)应该从\(j-1\)开始递减，也就是从最小的区间\([j-1, j]\)开始，逐步扩大区间。\(i\)不能从\(1\)开始递增，那样就是从大区间到小区间了。
for(int i=1; i<=n; i++) //n：石子堆数
dp[i][i] = 0; //初始化
for(int j=2; j<=n; j++) // 区间[i,j]的终点j，i<j<=n
for(int i=j-1;i>=1;i--) { // 区间[i,j]的起点i
dp[i][j]=INF; //初始化为极大值
for(int k=i;k<j;k++) //大区间[i,j]从小区间[i,k]和[k+1,j]转移而来
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j] + w[i][j]);
}
下面给出另外一种写法，它的\(i、j、k\)都是递增的，更容易理解，推荐使用。其中用了一个辅助变量\(len\)，它等于当前处理的区间\([i, j]\)的长度。\(dp[i][j]\)是大区间，它需要从小区间\(dp[i][k]\)和\(dp[k+1][j]\)转移而来，所以应该先计算出小区间，才能根据小区间算出大区间。\(len\)就起到了这个作用，从最小的区间\(len = 2\)开始，此时区间\([i, j]\)等于\([i, i+1]\)；最后是最大区间\(len = n\)，此时区间\([i, j]\)等于\([1, n]\)。
for(int i=1; i<=n; i++)
dp[i][i] = 0;
for(int len=2; len<=n; len++) //len：区间[i,j]的长度，从小区间扩展到大区间
for(int i=1; i<=n-len+1; i++){ // 区间起点i
int j = i + len - 1; // 区间终点j，i<j<=n
dp[i][j] = INF;
for(int k=i; k<j; k++)
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + w[i][j]);
}
区间DP的优化。上述代码的复杂度是\(O(n^3)\)，区间DP常常可以用“四边形不等式”进行优化，把复杂度提升到\(O(n^2)\)，详情见前面博文“四边形不等式”。经典例题“石子合并”也在这一篇进行了更详细的讲解。当然，不是所有的区间DP都能这样优化。
下面给出2个经典例题。请读者在看题解之前，自己思考并写出代码，一定会大有收获。
2. 例题
2.1. hdu 2476
String painter http://acm.hdu.edu.cn/showproblem.php?pid=2476
题目描述：给定两个长度相等的字符串A、B，由小写字母组成。一次操作，允许把A中的一个连续子串（区间）都转换为某个字符（就像用刷子刷成一样的字符）。要把A转换为B，问最低操作数是多少?
输入：第一行是字符串A，第二行是字符串B。两个字符串的长度不大于100。
输出：一个表示答案的整数。
输入样例：
zzzzzfzzzzz
abcdefedcba
输出样例：
6
提示：第1次把zzzzzfzzzzz转换为aaaaaaaaaaa，第2次转为abbbbbbbbba，第3次转为abccccccccba...
题解：
这道经典题，能帮助读者深入理解区间DP是如何构造和编码的。
（1）从空白串转换到B
先考虑简单一点的问题：从空白串转换到B。为方便阅读代码，把字符串存储为B[1]~B[n]，不从0开始，编码的时候这样输入：scanf("%s%s", A+1, B+1)。
如何定义DP状态？可以定义dp[\(i\)]，表示在区间[\(1, i\)]内转换为B的最少步数。或者更进一步，定义dp[\(i\)][\(j\)]，表示在区间[\(i, j\)]内从空白串转换到B时的最少步数。重点是区间[\(i, j\)]两端的字符B[\(i\)] 和B[\(j\)]，分析以下两种情况。
1）若B[\(i\)] = B[\(j\)]。第一次刷用B[\(i\)]把区间[\(i, j\)]刷一遍，这个刷法肯定是最优的。如果分别去掉两个端点，得到2个区间[\(i+1, j\)]、[\(i, j-1\)]，这2个区间的最小步数相等，也等于原区间[\(i, j\)]的最小步数。例如B[\(i, j\)]="abbba"，先用"a"全部刷一遍，再刷1次"bbb"，共刷2次。如果去掉第一个"a"，剩下的"bbba"，也是刷2次。
2）若B[\(i\)] ≠ B[\(j\)]。因为两端点不等，至少要各刷1次。用标准的区间操作，把区间分成\([i, k]\)和\([k+1, j]\)两部分，枚举最小步数。
下面是hdu 2476的代码，其中“从空白串转换到B”的代码完全套用了“石子合并”问题的编码。
#include <bits/stdc++.h>
using namespace std;
char A[105],B[105];
int dp[105][105];
const int INF = 0x3f3f3f3f;
int main() {
while(~scanf("%s%s", A+1, B+1)){ //输入A, B
int n = strlen(A+1);
for(int i=1;i<=n;i++)
dp[i][i]=1; //初始化
//先从空白串转换到B
for(int len=2; len<=n; len++)
for(int i=1; i<=n-len+1; i++){
int j = i + len-1;
dp[i][j] = INF;
if(B[i] == B[j]) //区间[i, j]两端的字符相同B[i] = B[j]
dp[i][j] = dp[i+1][j]; //或者 = dp[i][j-1])
else //区间[i, j]两端的字符不同B[i] ≠ B[j]
for(int k=i; k<j; k++)
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j]);
}
//下面从A转换到B
for(int j=1; j<=n; ++j){
if(A[j] == B[j])
dp[1][j] = dp[1][j-1]; //字符相同不用转
else
for(int k=1; k<j; ++k)
dp[1][j] = min(dp[1][j], dp[1][k] + dp[k+1][j]);
}
printf("%d\n",dp[1][n]);
}
return 0;
}
（2）从A转换到B
如何求dp[\(1\)][\(j\)]？观察A和B相同位置的字符，分析以下两种情况.
1）若A[\(j\)] = B[\(j\)]。这个字符不用转换，有dp[\(1\)][\(j\)] = dp[\(1\)][\(j-1\)]。
2）若A[j] ≠ B[j]。仍然用标准的区间DP，把区间分成\([1, k]\)和\([k+1, j]\)两部分，枚举最小步数。这里利用了上一步从空白转换到B的结果，当区间\([k+1, j]\)内A和B的字符不同时，从A转到B，与从空白串转换到B是等价的。
2.2. hdu 4283
You Are the One http://acm.hdu.edu.cn/showproblem.php?pid=4283
题目描述：n个男孩去相亲，排成一队上场。大家都不想等，排队越靠后越愤怒。每人的耐心不同，用D表示火气，设男孩\(i\)的火气是D\(_i\)，他排在第\(k\)个时，愤怒值是(\(k-1)*D_i\)。
导演不想看到会场气氛紧张。他安排了一个黑屋，可以调整这排男孩上场的顺序，屋子很狭长，先进去的男孩最后出来（黑屋就是一个堆栈）。例如，当男孩A排到时，如果他后面的男孩B火气更大，就把A送进黑屋，让B先上场。一般情况下，那些火气小的男孩要多等等，让火气大的占便宜。不过，零脾气的你也不一定吃亏，如果你原本排在倒数第二个，而最后一个男孩脾气最坏，导演为了让这个刺头第一个上场，把其他人全赶进了黑屋，结果你就排在了黑屋的第1名，第二个上场相亲了。
注意，每个男孩都要进出黑屋。
对所有男孩的愤怒值求和，求所有可能情况的最小和。
输入：第一行包含一个整数T，即测试用例的数量。对于每种情况，第一行是n（0 <n <= 100），后面n行，整数D\(_1\)-D\(_n\)表示男孩的火气值（0 <= D\(_i\) <= 100）。
输出：对每个用例，输出最小愤怒值之和。
题解：
读者可以试试用栈来模拟，非常困难。这是一道区间DP，巧妙地利用了栈的特性。
定义dp[\(i\)][\(j\)]，表示从第\(i\)个人到第\(j\)个人，即区间[\(i, j\)]的最小愤怒值之和。
由于栈的存在，这一题的区间[\(i, j\)]的分割点\(k\)比较特殊。分割时，总是用区间[\(i, j\)]的第一个元素\(i\)把区间分成两部分，让\(i\)第\(k\)个从黑屋出来上场相亲，即第\(k\)个出栈。根据栈的特性：若第一个元素\(i\)第\(k\)个出栈，则第二到\(k-1\)个元素肯定在第一个元素之前出栈，第\(k+1\)到最后一个元素肯定在第\(k\)个之后出栈[2]。
例如，5个人排队序号是1、2、3、4、5。如果要第1（\(i\)=1）个人第3（\(k\)=3）个出场，那么栈的操作是这样：1进栈、2进栈、3进栈、3出栈、2出栈，1出栈。2号、3号在1号之前出栈，1号第3个出栈，4号5号在1号后面出栈。
分割点\(k\)（1≤ k≤j-i+1）把区间划分成了两段，即dp[\(i+1\)][\(i+k-1\)]和dp[\(i+k\)][\(j\)]。dp[\(i\)][\(j\)]的计算分为三部分：
（1）dp[\(i+1\)][\(i+k-1\)]。原来\(i\)后面的\(k-1\)个人，现在排到\(i\)前面了。
（2）第\(i\)个人往后挪了\(k-1\)个位置，愤怒值加上D[\(i\)]*(\(k-1\))。
（3）dp[\(i+k\)][\(j\)] + \(k*(sum[j] - sum[i+k-1]\))。第k个位置后面的人，即区间[\(i+k, j\)]的人，由于都在前\(k\)个人之后，相当于从区间的第1个位置往后挪了\(k\)个位置，所以整体愤怒值要加上\(k*(sum[j]-sum[i+k-1])\)。其中\(sum[j]=\sum_{i=1}^jD_i\)，是1~j所有人D值的和，\(sum[j] - sum[i+k-1]\)是区间[\(i+k, j\)]内这些人的D值和。
代码完全套用“石子合并”的模板。其中DP方程给出了两种写法，对照看更清晰。
for(int len=2; len<=n; len++)
for(i=1;i<=n-len+1;i++) {
j = len + i - 1;
dp[i][j] = INF;
for(int k=1;k<=j-i+1;k++) //k：i往后挪了k位。这样写容易理解
dp[i][j] = min(dp[i][j], dp[i+1][i+k-1] + D[i]*(k-1)
+ dp[i+k][j] + k*(sum[j]-sum[i+k-1])); //DP方程
//for(int k=i;k<=j;k++) //或者这样写。k是整个队伍的绝对位置
// dp[i][j] = min(dp[i][j], dp[i+1][k] + D[i]*(k-i)
+ dp[k+1][j] + (k-i+1)*(sum[j]-sum[k]));
}
2.3. 二维区间DP
前面的例子的区间[\(i, j\)]可以看成在一条直线上移动，即一维DP。这里给出一个二维区间DP的例题，它的区间同时在两个方向移动。
CF1199 F. Rectangle Painting （提交地址 https://vjudge.net/problem/CodeForces-1199F）
题目描述： 有一个n×n大小的方格图，某些方格初始是黑色，其余为白色。一次操作，可以选定一个h×w的矩形，把其中所有方格涂成白色，代价是max(h, w)。要求用最小的代价把所有方格变成白色。
输入： 第1行是整数n，表示方格的大小。后面有n行，每行长度为n的串，包含符号'.'和'#'，'.'表示白色，'#'表示黑色。第i行的第j个字符是(i, j)。n ≤ 50。
输出：打印一个整数，表示把所有方格涂成白色的最小代价。
输入样例：
5
#...#
.#.#.
.....
.#...
#....
输出样例：
5
题解：
设矩形区域从左下角坐标\((x1,y1)\)到右上角坐标\((x2,y2)\)。定义状态dp\([x1][y1][x2][y2]\)，表示把这个区域内染成白色的最小代价。
这个区域可以分别按\(x\)轴或者按\(y\)轴分割成两个矩形，遍历所有可能的分割，求最小代价。那么从\(x\)方向看，就是一个区间DP；从\(y\)方向看，也是区间DP。
代码可以完全套用前面一维DP的模板，分别在两个方向操作。
（1）\(x\)方向，区间分为\([x1, k]\)和\([k+1, x2]\)。状态转移方程是：
dp\([x1][][x2][]\) = min(dp\([x1][][x2][]\), dp\([x1][][k][]\) + dp\([k+1][][x2][])\)
（2）\(y\)方向，区间分为\([y1, k]\)和\([k+1, y2]\)。状态转移方程是：
dp\([][y1][][y2]\) = min(dp\([][y1][][y2]\), dp\([][y1][][k]\) + dp\([][k+1][][y2]\))
下面的代码[3]有5层循环，时间复杂度\(O(n^5)\)。对比一维区间DP，有3层循环，复杂度是\(O(n^3)\)。
#include<bits/stdc++.h>
using namespace std;
#define N 55
int dp[N][N][N][N];
char mp[N][N]; //方格图
int main(){
int n; cin>>n;
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
cin>>mp[i][j];
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(mp[i][j]=='.') dp[i][j][i][j]=0; //白格不用涂
else dp[i][j][i][j]=1; //黑格(i,j)涂成白色需1次
for(int lenx=1;lenx<=n;lenx++) //len从1开始，不是2。因为有x和y两个方向
for(int leny=1;leny<=n;leny++)
for(int x1=1;x1<=n-lenx+1;x1++)
for(int y1=1;y1<=n-leny+1;y1++){
int x2 = x1+lenx-1; //x1：x轴起点；x2：x轴终点
int y2 = y1+leny-1; //y1：y轴起点；y2：y轴终点
if(x1==x2 && y1==y2) continue; //lenx=1且leny=1的情况
dp[x1][y1][x2][y2] = max(abs(x1-x2),abs(y1-y2)) + 1; //初始值
for(int k=x1;k<x2;k++) //枚举x方向，y不变。区间[x1,k]+[k+1,x2]
dp[x1][y1][x2][y2] = min(dp[x1][y1][x2][y2],
dp[x1][y1][k][y2]+dp[k+1][y1][x2][y2]);
for(int k=y1;k<y2;k++) //枚举y方向，x不变。区间[y1,k]+[k+1,y2]
dp[x1][y1][x2][y2] = min(dp[x1][y1][x2][y2],
dp[x1][y1][x2][k]+dp[x1][k+1][x2][y2]);
}
cout << dp[1][1][n][n];
}
3. 习题
邝斌带你飞“区间DP”：https://vjudge.net/contest/77874#overview
力扣的DP题目：https://leetcode-cn.com/circle/article/NfHhXD/
二维区间DP：poj 1191 http://poj.org/problem?id=1191
区间DP、树形DP、状态压缩DP、数位DP这些名词，可能是中国算法竞赛选手创造的。在英文网站上可以这样搜索对应的英文：区间DP，DP over intervals；树形DP，DP on trees；状态压缩DP，DP on subsets。 ↩︎
这里有个图解：https://blog.csdn.net/weixin_41707869/article/details/99686868 ↩︎
