[学习笔记]区间类动态规划

区间类动态规划是一种比较特殊的动态规划，以区间作为动态规划的阶段，套路性比较强。

怎样的套路？

状态的表示一般都是：设 $d{p}_{i,j}$ 为从 $i$ 到 $j$ 的区间的XXX。

转移的顺序也很固定，基本都是先求小区间，再求大区间。我们甚至可以写出一个区间 DP 的模板：

//初始化
for(int len = 1; len <= n; len++)  //枚举区间长度
//len的初始值不一定为1,需要看具体情况
{
    for(int i = 1; i + len - 1 <= n; i++)  //枚举左端点
    {
        int j = i + len - 1;  //算出右端点
        for(int k = i; k < j; k++)  //枚举区间的断点
        {
            //状态转移
        }
    }
}

但是记住，千万不要记这个！ 这只是告诉大家区间动态规划的常见思路——求区间的解时枚举断点，由左右两部分的解合并出该区间的解。

使用情境

区间 DP 的使用情境还是比较明显的：

• 每次都会操作一个区间，或者操作区间的首尾两端；
• 出现了区间的分解、合并等操作（其实分解就是合并的逆操作），所以能将问题分解成两两合并的形式。

总结一句话：题目做多了，看到就自然知道要用区间类动态规划了。

---

例题

NOI1995 石子合并

我们先解决一下这个问题的简化版本：一本通5.1例1 石子合并

设 $d{p}_{i,j}$ 表示把区间 $[i,j]$ 合并成一堆的最小/最大得分。那么求最小得分就是：
d p i , j = min ⁡ i ≤ k < j { d p i , k + d p k + 1 , j } + s u m j − s u m i − 1 dp_{i,j} = \min_{i \le k \lt j}\{dp_{i,k}+dp_{k+1,j}\} + sum_j - sum_{i - 1} dpi,j​=i≤k<jmin​{dpi,k​+dpk+1,j​}+sumj​−sumi−1​

最大得分同理。其中 $su{m}_i={\sum }_{j=1}^i{a}_j$，即前缀和。

那么我们就要解决原问题了，接下来要谈到一种非常重要的 套路 解题思想——破环为链。

我们把环从中间断开然后再复制一遍，做一遍区间 DP，然后每一个长为 $n$ 的区间都是一个合法的解。

Q：为什么这样是对的呢？
A：因为通过复制一遍，我们满足了首尾相接，这个链上每一个长度为 $n$ 的区间就相当于原来环的一种断开方式。

如果还不能理解，可以看看代码，好好思考：

#include <iostream>
#include <cstring>
#include <limits.h>
using namespace std;
const int maxn = 410;
long long a[maxn / 2], sum[maxn], dp[maxn][maxn];
int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 1; i <= 2 * n; i++)
        if (i <= n)
            sum[i] = sum[i - 1] + a[i];
        else
            sum[i] = sum[i - 1] + a[i - n];
    memset(dp, 0x7f, sizeof(dp));
    for (int i = 1; i <= 2 * n; i++) dp[i][i] = 0;
    for (int len = 2; len <= 2 * n; len++)
        for (int i = 1; i + len - 1 <= 2 * n; i++) {
            int j = i + len - 1;
            for (int k = i; k < j; k++)
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + sum[j] - sum[i - 1]);
        }
    long long ans = LONG_LONG_MAX;
    for (int i = 1; i <= n; i++) ans = min(ans, dp[i][i + n - 1]);
    cout << ans << endl;
    memset(dp, 0, sizeof(dp));
    for (int len = 2; len <= 2 * n; len++)
        for (int i = 1; i + len - 1 <= 2 * n; i++) {
            int j = i + len - 1;
            for (int k = i; k < j; k++)
                dp[i][j] = max(dp[i][j], dp[i][k] + dp[k + 1][j] + sum[j] - sum[i - 1]);
        }
    ans = 0;
    for (int i = 1; i <= n; i++) ans = max(ans, dp[i][i + n - 1]);
    cout << ans << endl;
    return 0;
}

一本通5.1练习2 分离与合体

仔细琢磨其本质，你会发现这就是 NOIP2006提高组 能量项链 的变形加上一个方案的输出。

我们用我们在“基本概念和杂项”中所讲的决策方案输出的方法，转移时记录下每一步是从哪里转移过来的，然后输出即可。

附代码以供参考：

#include <iostream>
#include <queue>
using namespace std;
const int maxn = 305;
int a[maxn], dp[maxn][maxn], from[maxn][maxn];

queue<pair<int, int> > q;

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int len = 2; len <= n; len++)
        for (int i = 1; i + len - 1 <= n; i++) {
            int j = i + len - 1, target;
            for (int k = i; k < j; k++) {
                int tmp = dp[i][k] + dp[k + 1][j] + (a[i] + a[j]) * a[k];
                if (tmp > dp[i][j]) {
                    dp[i][j] = tmp;
                    target = k;
                }
            }
            from[i][j] = target;
        }
    cout << dp[1][n] << endl;
    q.push(make_pair(1, n));
    while (!q.empty()) {
        pair<int, int> tmp = q.front();
        q.pop();
        int l = tmp.first, r = tmp.second;
        if (l == r)
            continue;
        cout << from[l][r] << ' ';
        q.push(make_pair(l, from[l][r]));
        q.push(make_pair(from[l][r] + 1, r));
    }
    cout << endl;
    return 0;
}

NOIP2007提高组 矩阵取数游戏

发现每一行是独立的，互不影响的。采用贪心策略，我们每一行取得分数都要尽可能大，然后各行的最大分数加起来就是最后的答案。

而我们每一行都只能取行首或者行尾，发现剩下的一定是一个区间，所以想到区间 DP。

这题写了记忆化搜索的形式，为了方便理解算法思想和代码的精髓，采用 __int128 代替高精度，勿喷。

#include<iostream>
#include<cstdio>
using namespace std;
typedef __int128 ll;
int n, m;
const int maxn = 85;
ll a[maxn][maxn], dp[maxn][maxn][maxn];

inline ll read()
{
	ll x = 0;
	bool flag = true;
	char ch = getchar();
	while(ch < '0' || ch > '9')
	{
		if(ch == '-')
			flag = false;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9')
	{
		x = x * 10 + ch - 48;
		ch = getchar();
	}
	return flag ? x : -x;
}

void print(ll x)
{
	if(x == 0)
		return;
	if(x < 0)
	{
		putchar('-');
		x = -x;
	}
	print(x / 10);
	putchar(x % 10 + 48);
	return;
}

ll dfs(int l, int r, int x)
{
	if(dp[l][r][x] != -1)
		return dp[l][r][x];
	if(l == r)
		return dp[l][r][x] = a[x][l] << 1;
	ll ans = 0;
	ans = max(ans, dfs(l + 1, r, x) + a[x][l] << 1);
	ans = max(ans, dfs(l, r - 1, x) + a[x][r] << 1);
	return dp[l][r][x] = ans;
}

int main()
{
	for(int i = 0; i < maxn; i++)
		for(int j = 0; j < maxn; j++)
			for(int k = 0; k < maxn; k++)
				dp[i][j][k] = -1;
	scanf("%d%d", &n, &m);
	for(int i = 1; i <= n; i++)
		for(int j = 1; j <= m; j++)
			a[i][j] = read();
	ll ans = 0;
	for(int i = 1; i <= n; i++)
		ans += dfs(1, m, i);
	if(ans == 0)
		printf("0\n");
	else
		print(ans);
	return 0;
}

总体来说，基础的区间 DP（不含优化）是较为简单的一类动态规划问题。