区间动态规划

区间 DP是指在一段区间上进行的一系列动态规划。 对于区间 DP 这一类问题，我们需要计算区间 [1,n] 的答案，通常用一个二维数组 dp 表示，其中 dp[x][y] 表示区间 [x,y]。 有些题目，dp[l][r] 由 dp[l][r−1] 与 dp[l+1][r] 推得；也有些题目，我们需要枚举区间 [l,r] 内的中间点，由两个子问题合并得到，也可以说 dp[l][r] 由 dp[l][k] 与 dp[k+1][r] 推得，其中 l≤k<r。 对于长度为 n 的区间 DP，我们可以先计算 [1,1],[2,2]…[n,n] 的答案，再计算 [1,2],[2,3]…[n−1,n]，以此类推，直到得到原问题的答案。

一道经典例题：

NOI 1995 石子合并

题目描述

在一个圆形操场的四周摆放N堆石子,现要将石子有次序地合并成一堆.规定每次只能选相邻的2堆合并成新的一堆，并将新的一堆的石子数，记为该次合并的得分。

试设计出1个算法,计算出将N堆石子合并成1堆的最小得分和最大得分.

输入输出格式

输入格式：

数据的第1行试正整数N,1≤N≤100,表示有N堆石子.第2行有N个数,分别表示每堆石子的个数.

输出格式：

输出共2行,第1行为最小得分,第2行为最大得分.

输入输出样例

输入样例#1：

4
4 5 9 4

输出样例#1：

43
54

分析

我们利用动态规划的思想，将问题不断分为子问题，为了求出最终最小的代价，我们只要求两堆的最小代价，再求出三堆的最小代价，以此类推得出最终的最小代价。

我们用 dp[i][j] 来表示合并 i 到 j 区间里的石子的最小代价。然后我们写出下面的公式：

dp[i][j]=min(dp[i][k]+dp[k+1][j])+sum[j]−sum[i−1]

显然通过这个式子，我们可以按区间长度从小到大的顺序进行枚举来不断让石子进行合并，最终就能获得合并成一堆石子的最小代价。

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500 + 10;
int n, stone[2*MAXN], mi[2*MAXN][2*MAXN], mx[2*MAXN][2*MAXN], s[2*MAXN];
int main()
{
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> stone[i], stone[i+n] = stone[i];
    for (int i = 1; i <= 2*n; i++)
        s[i] = s[i-1] + stone[i];
    for (int i = 2*n-1; i >= 1; i--)
    {
        for (int j = i+1; j < n+i; j++)
        {
            mi[i][j] = 0x3F3F3F3F;
            for (int k = i; k < j; k++)
            {
                mi[i][j] = min(mi[i][j], mi[i][k]+mi[k+1][j]+s[j]-s[i-1]);
                mx[i][j] = max(mx[i][j], mx[i][k]+mx[k+1][j]+s[j]-s[i-1]);
            }
        }
    }
    int ans1 = 0x3F3F3F3f, ans2 = 0;
    for (int i = 1; i <= n; i++)
        ans1 = min(ans1, mi[i][i+n-1]), ans2 = max(ans2,mx[i][i+n-1]);
    cout << ans1 << endl << ans2 << endl;
    return 0;
}