区间DP 石子合并 C++

区间DP是一种动态规划的方法，用于解决涉及区间的问题。它通常应用于需要确定区间的最优解或最值的情况下。

石子合并问题是一个经典的区间DP问题，可以用区间DP方法解决。给定一行n个石子，每个石子有一个价值，现要将石子合并成若干堆，每次只能选择相邻的两堆进行合并，合并的得分为两堆石子的总价值，合并后的新堆的价值为得分。求合并到最后，最终得到的堆的最大价值。

要求解石子合并问题，可以定义一个dp数组，dp[i][j]表示合并第i个石子到第j个石子所能得到的最大价值。则有如下的状态转移方程：

dp[i][j] = max{dp[i][k] + dp[k+1][j] + sum[i][j]}，其中i <= k < j，sum[i][j]表示第i个石子到第j个石子的总价值。

根据这个状态转移方程，可以使用两层循环来计算dp数组的值，最终dp[1][n]就是所求的结果。

区间DP是一个常见且重要的动态规划方法，可以用来解决许多实际问题。石子合并问题是区间DP的一个经典例子，通过合理定义状态和状态转移方程，可以高效地求解问题。

#include <bits/stdc++.h>
#define ll long long
#define endl "\n"
#define KUI ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
using namespace std;
const int con = 310;
const int mod = 998244353;
int n, m, k, f[con][con], a[con], s[con];
void take()
{
    memset(f, 127, sizeof f);
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        s[i] = s[i - 1] + a[i]; // 前缀和;
        f[i][i] = 0;            // 石子从i到i消耗为0;
    }
    for (int len = 2; len <= n; len++)         // 枚举区间长度;
    {                                          // 从小到大的长度枚举计算区间消耗最小值;
        for (int l = 1; l + len - 1 <= n; l++) // 枚举区间起点;
        {
            int r = l + len - 1;        // 区间终点;
            for (int k = l; k < r; k++) // 枚举分割点;
            {
                f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);
                // f[l][k] + f[k + 1][r](原先l到k,k+1到r的合并消耗值) + s[r] - s[l - 1](合并l到r消耗值);
            }
        }
    }
    cout << f[1][n] << endl;
}
int main()
{
    KUI;
    int t1 = 1;
    while (t1--)
    {
        take();
    }
    return 0;
}

圆形区间DP

#include <bits/stdc++.h>
#define ll long long
#define endl "\n"
#define KUI ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
using namespace std;
const int con = 610;
const int mod = 998244353;
int n, m, k, f[con][con], a[con], s[con], f2[con][con];
void take()
{
    memset(f, 127, sizeof f);
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];
        a[n + i] = a[i]; // 石子从i到i消耗为0;
        f[i][i] = 0;
        f[n + i][n + i] = 0;
    }
    for (int i = 1; i <= 2 * n; i++)
    {
        s[i] = s[i - 1] + a[i];
    }
    for (int len = 2; len <= n; len++)             // 枚举区间长度;
    {                                              // 从小到大的长度枚举计算区间消耗最小值;
        for (int l = 1; l + len - 1 <= 2 * n; l++) // 枚举区间起点;
        {
            int r = l + len - 1;        // 区间终点;
            for (int k = l; k < r; k++) // 枚举分割点;
            {
                f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);
                // f[l][k] + f[k + 1][r](原先l到k,k+1到r的合并消耗值) + s[r] - s[l - 1](合并l到r消耗值);
            }
        }
    }
    for (int len = 2; len <= n; len++)             // 枚举区间长度;
    {                                              // 从小到大的长度枚举计算区间消耗最小值;
        for (int l = 1; l + len - 1 <= 2 * n; l++) // 枚举区间起点;
        {
            int r = l + len - 1;        // 区间终点;
            for (int k = l; k < r; k++) // 枚举分割点;
            {
                f2[l][r] = max(f2[l][r], f2[l][k] + f2[k + 1][r] + s[r] - s[l - 1]);
                // f[l][k] + f[k + 1][r](原先l到k,k+1到r的合并消耗值) + s[r] - s[l - 1](合并l到r消耗值);
            }
        }
    }
    int ans1 = mod, ans2 = 0;
    for (int i = 1; i <= n; i++)
    {
        ans1 = min(ans1, f[i][i + n - 1]);
        ans2 = max(ans2, f2[i][i + n - 1]);
    }
    cout << ans1 << endl;
    cout << ans2 << endl;
}
int main()
{
    KUI;
    int t1 = 1;
    while (t1--)
    {
        take();
    }
    return 0;
}