[动态规划] 区间 dp
区间 dp
石子合并
将区间长度 \(len\) 作为 \(dp\) 的阶段
设 \(f[l][r]\) 表示把最初的第 \(l\) 堆到第 \(r\) 堆石子合并成一堆，需要消耗的最少体力。
合并代价就是这两堆石子的质量和，这里可以用前缀和直接计算，设 \(s[i]\) 表示前 \(i\) 堆石子的质量和。
状态转移方程：
计算 max 同理
注意，由于需要破环为链，不能直接将答案返回 \(f[1][n]\) ，要在计算过程中更新答案。
int f[N][N];
int n;
int a[N], s[N];
int cost(int l, int r){return s[r] - s[l - 1];}
int dp_min()
{
int minn = inf;
for (rint len = 1; len < n; len++)
{
for (rint l = 1; l <= 2 * n - len; l++)
{
int r = l + len;
f[l][r] = inf;
for (rint k = l; k < r; k++) f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + cost(l, r));
if (len + 1 == n) minn = min(minn, f[l][r]);
}
}
return minn;
}
int dp_max()
{
int maxx = 0;
for (rint len = 1; len < n; len++)
{
for (rint l = 1; l <= 2 * n - len; l++)
{
int r = l + len;
f[l][r] = 0;
for (rint k = l; k < r; k++) f[l][r] = max(f[l][r], f[l][k] + f[k + 1][r] + cost(l, r));
if (len + 1 == n) maxx = max(maxx, f[l][r]);
}
}
return maxx;
}
signed main()
{
cin >> n;
for (rint i = 1; i <= n * 2; i++)
{
if (i <= n)
{
cin >> a[i];
a[i + n] = a[i];
}
s[i] = s[i - 1] + a[i];
}
cout << dp_min() << endl << dp_max() << endl;
return 0;
}
P4342 [IOI1998] Polygon
本题要求的是区间合并的最大得分，很明显是区间 \(dp\) 问题。
把被删除的边逆时针方向的顶点称为 "第 \(1\) 个顶点"，依此类推。然后用区间 \(dp\) 常见的状态表示。
设 \(f[l][r]\) 表示把第 \(l\) 到 \(r\) 个顶点合成的最大得分。
状态表示没有什么问题，但是状态转移出现了问题，我们并不能通过 \(f[l][k]\) 和 \(f[k + 1][r]\) 来得到 \(f[l][r]\)
有可能 \(l\) ~ \(k\) 的某种得分是负数 \(a\)，\(k + 1\) ~ \(r\) 的某种得分也是负数 \(b\)，但是 \(a * b\) 可能比 \(f[l][k] * f[k + 1][r]\) 更大。
由此得出状态转移的错误性，那么我们应该如何得出 \(f[l][r]\) 呢，首先分析 \(l ~ r\) 的最大得分有几种可能得到：
max(l ~ k) + max(k + 1 ~ r)max(l ~ k) * max(k + 1 ~ r)min(l ~ k) * min(k + 1 ~ r)(负负得正)
通过分析可以发现，要想得出 \(f[l][r]\) 需要知道子状态的最大值和最小值。
设 \(f[l][r][0]\) 表示把第 \(l\) 到 \(r\) 个顶点合成的最大得分，\(f[l][r][1]\) 表示把第 \(l\) 到 \(r\) 个顶点合成的最小得分
那么我们每次转移都需要转移最大值和最小值，上面已经分析最大值的转移，再分析一下最小值的转移：
min(l ~ k) + min(k + 1 ~ r)min(l ~ k) * min(k + 1 ~ r)max(l ~ k) * max(k + 1 ~ r)max(l ~ k) * min(k + 1 ~ r)min(l ~ k) * max(k + 1 ~ r)
起始状态为 \(f[i][i][0] = f[i][i][1] = a[i]\)，结束状态为 \(f[1][n][0]\)
以上就是全部的状态转移，另外还需要考虑第一步要删除哪条边。这里采用拆环成链的技巧，例如，将 - a - b - c - d - 拆成 a - b - c - d - a - b - c - d 这时枚举所有以前一半为端点的链，就能找出所有的情况。
a - b - c - d 拆 d - a
b - c - d - a 拆 a - b
c - d - a - b 拆 b - c
d - a - b - c 拆 c - d
最终枚举所有的链从中取最大值即可。
int n;
int a[N];
//原序列
char op[N];
//操作序列
//f[l][r][0] 表示把第 l 到 r 个顶点合成的最大得分
//f[l][r][1] 表示把第 l 到 r 个顶点合成的最小得分
int f[N][N][2];
signed main()
{
cin >> n;
//接收原序列、操作序列
for (rint i = 1; i <= 2 * n; i++)
if (!(i % 2)) cin >> a[i / 2];
else scanf("%s", &op[(i + 1) / 2]);
//初始化
for (rint l = 1; l <= 2 * n; l++)
for (rint r = 1; r <= 2 * n; r++)
f[l][r][0] = -inf, f[l][r][1] = inf;
//拆环成链
for (rint i = 1; i <= n; i++)
{
a[i + n] = a[i];
op[i + n] = op[i];
f[i][i][0] = f[i + n][i + n][0] = f[i][i][1] = f[i + n][i + n][1] = a[i];
}
for (rint len = 1; len < n; len++)
{
for (rint l = 1; l + len <= 2 * n; l++)
{
int r = l + len;
for (rint k = l; k < r; k++)
if (op[k + 1] == 't') //加法
{
f[l][r][0] = max(f[l][r][0], f[l][k][0] + f[k + 1][r][0]);
f[l][r][1] = min(f[l][r][1], f[l][k][1] + f[k + 1][r][1]);
}
else //乘法
{
f[l][r][0] = max(f[l][r][0], f[l][k][0] * f[k + 1][r][0]);
f[l][r][0] = max(f[l][r][0], f[l][k][1] * f[k + 1][r][1]);
f[l][r][1] = min(f[l][r][1], f[l][k][1] * f[k + 1][r][1]);
f[l][r][1] = min(f[l][r][1], f[l][k][1] * f[k + 1][r][0]);
f[l][r][1] = min(f[l][r][1], f[l][k][0] * f[k + 1][r][1]);
f[l][r][1] = min(f[l][r][1], f[l][k][0] * f[k + 1][r][0]);
}
}
}
//枚举所有链取最大值
int res = -inf;
for (rint i = 1; i <= n; i++) res = max(res, f[i][i + n - 1][0]);
cout << res << endl;
//找出所有能取到最大值的顶点
for (rint i = 1; i <= n; i++)
if (res == f[i][i + n - 1][0])
cout << i << " ";
return 0;
}
AcWing 284. 金字塔
设 \(f[l][r]\) 表示子串 \(s[l\) ~ \(r]\) 对应多少种可能的树形结构。
然后考虑对区间的划分，根据区间的划分不同，也可能得出不同的树形结构。
若 \(s[l\) ~ \(r]\) 对应一棵子树，那么 \(s[l]\) 和 \(s[r]\) 就应该是树根，\(s[l + 1]\) 和 \(s[r - 1]\) 就是进入和离开子树时的节点。
除此之外，\([l, r]\) 包含的每棵更深的子树都对应一个子问题，会产生 \([l, r]\) 中的一段，相邻两段之间还有途经树根产生
的一个字符。由于 \([l, r]\) 包含的子树个数可能不止两个，如果我们朴素的枚举划分点的数量和所有划分点的位置，那么
时间复杂度会高得离谱。
因此我们可以换种思路，尝试把 $s[l $ ~ $ r]$ 分成两部分，每部分可由若干棵子树组成，不过这样可能会产生重复计数。
如果每段都可以由多棵子树构成，如 "ABABABA"，划分成 "A|BAB|A|B|A" 和 "A|B|A|BAB|A"，其中 "BAB" 都能产生 "B|A|B"
两棵子树，那么这两种划分方式最终就会变成同一种结果。
为了解决不重不漏，我们可以只考虑子串 \([l\) ~ \(r]\) 的第一棵子树时由哪一段构成的，枚举划分点$ k$，令子串 \(s[l + 1\) ~ \(k - 1]\)
构成 \([l, r]\) 的第一棵子树，\(s[k\) ~ \(r]\) 构成 \([l, r]\) 的剩余部分（其他子树）。
如果 \(k\) 不相同，那么子串 \(s[l + 1\) ~ \(k - 1]\) 代表的子树的大小也不相同，就不可能产生重复计算的结构。
由此得出状态转移方程，当 \(s[l]≠s[r]\)
当 \(s[l]=s[r]\)
起始状态为 \(f[i][i] = 1\)，目标状态为 \(f[1][n]\)
char str[N];
int f[N][N];
//表示子串 s[l ~ r] 对应多少种可能的树形结构
int dfs(int l, int r)
{
if (l > r) return 0; //不合法的状态方案数为 0
if (l == r) return 1; //一个节点无法划分，方案数为 1
if (f[l][r] != -1) return f[l][r]; //如果当前区间已经计算过，直接返回结果
if (str[l] != str[r]) return 0; //不是一棵完整的子树，方案数为 0
//到这说明当前区间没计算过
f[l][r] = 0; //最开始方案数为 0
for (rint k = l + 2; k <= r; k++) //枚举划分点
f[l][r] = (f[l][r] + dfs(l + 1, k - 1) * dfs(k, r)) % mod; //累加方案数
return f[l][r]; //将 [l ~ r] 的方案数往回传
}
signed main()
{
scanf("%s", str + 1);
memset(f, -1, sizeof f); //记忆化搜索初始化，没有计算过的状态默认为 -1
cout << dfs(1, strlen(str + 1)) << endl; //递归计算整个区间
return 0;
}
