Dp-区间DP：环形石子合并

在区间石子合并的基础上，现在取消了对起点和终点的限制，起点和终点也可以直接相连，进行合并了。这样对于所有的点来说，大家一样烂

朴素的想法

那不管怎么合并，最后在这n个点中，肯定要连一个长度为n-1的链，那我就枚举这个链子所有可能的缺口，然后，每种情况做一次区间dp呗。一次区间dp的时间复杂度时O(n^3 )，这样环形的话会到O(n^4)

200的4次方会爆掉。

然后牛逼的方式出现了。
在2*n的链子上做区间长度为n的区间dp，不要太帅。时间复杂度变为O((2n) ^ 3).

区间dp的两种方式

枚举区间长度，然后枚举起点。然后枚举这个区间内的分割点。

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 410, INF = 0x3f3f3f3f;

int n;
int w[N], s[N];
// f处理最小值，g处理最大值
int f[N][N], g[N][N];

int main()
{
    cin >> n;
    for (int i = 1; i <= n; i ++ )
    {
        cin >> w[i];
        // 长度为n变成长度为2n
        w[i + n] = w[i];
    }

    // 前缀和方便求区间和。
    for (int i = 1; i <= n * 2; i ++ ) s[i] = s[i - 1] + w[i];

    // 初始化。
    memset(f, 0x3f, sizeof f);
    memset(g, -0x3f, sizeof g);

    for (int len = 1; len <= n; len ++ )
        for (int l = 1; l + len - 1 <= n * 2; l ++ )
        {
            int r = l + len - 1;
            // 状态初始化。区间长度为0，代价为0
            if (l == r) f[l][r] = g[l][r] = 0;
            else
            {   
                // 分割点取到左端点，取不到右端点，下边有k+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]);
                    g[l][r] = max(g[l][r], g[l][k] + g[k + 1][r] + s[r] - s[l - 1]);
                }
            }
        }

    int minv = INF, maxv = -INF;
    for (int i = 1; i <= n; i ++ )
    {
        minv = min(minv, f[i][i + n - 1]);
        maxv = max(maxv, g[i][i + n - 1]);
    }

    cout << minv << endl << maxv << endl;

    return 0;
}