1.分析題目
現要將石子有次序地合并成一堆，要求&條件：規定每次只能選相鄰的2堆合并成新的一堆，
并將新的一堆的石子數，記為該次合并的得分。
2.思考
不難發現這需要進行區間操作，我們同樣可以聯想到使用區間動態規劃，因此可以解決子問題重疊的問題，減少時間復雜度
3.設計
通過3層for循環完成計算。計算前先初始化dp_max&dp_min變量還有計算1-n前綴和，以便后面的對比、計算
4.計算
根據
dp_max[i][j]=max{dp_max[i][j],dp_max[i][k]+dp_max[k+1][j]+sum[j]-sum[k-1]}
dp_min[i][j]=min{dp_min[i][j],dp_min[i][k]+dp_min[k+1][j]+sum[j]-sum[k-1]}
解釋一下公式，它們的作用都是獲取某個區間的最大或者最小得分，原理是通過區間遍歷的方法，分成很多個兩份，計算前綴和，相加，
再，最后再加上區間的總前綴和進行比對。
5.得出結果
我們直接可以用一個for循環遍歷一遍dp_max&dp_min數組獲取它們的最大或最小值
6.總結
用動態規劃的算法來解此道題可以優化重復計算的一些問題，因而減少時間復雜度。

#include<iostream>
#include<cstring>
#include <algorithm>
using namespace std;
int dp_max[510][510], dp_min[510][510], sum[510], v = 0, dp_mint[5010];
int main()
{
    int n, s;
    cin >> n;
    
    memset(dp_max, 0, sizeof(dp_max));
    memset(dp_min, 0, sizeof(dp_min));
    memset(sum, 0, sizeof(sum));
    memset(dp_mint, 0, sizeof(dp_mint));
    
    for (int i = 1; i <= n; i++) {
        cin >> s;
        dp_mint[i] = s; v += s; sum[i] = v;
    }
    for (int i = n + 1; i <= n * 2; i++) {
        dp_mint[i] = dp_mint[i - n]; v += dp_mint[i]; sum[i] = v;
    }
    //初始化MIN
    for (int u = 1; u <= 2 * n; u++)
    {
        for (int j = u+1; j <= 2 * n; j++)
        {
            dp_min[u][j] = 500000000;
        }
    }
    for(int L=2;L<=n;L++)//從2開始
        for (int i = 1; i <= 2*n-L+1; i++) {//i=2*n+1 i:區間起點
            int j = i + L - 1;//區間結尾
            for (int k = i ; k <= j-1; k++)//k=i第1部分d結尾
            {
                dp_max[i][j] = max(dp_max[i][j], dp_max[i][k] + dp_max[k + 1][j] + sum[j] - sum[i - 1]);
                dp_min[i][j] = min(dp_min[i][j], dp_min[i][k] + dp_min[k + 1][j] + sum[j] - sum[i - 1]);
            }
        }
    int q;
    int Max1 = 0; int Min1 = 500000000;
    for (q = 1; q <= n; q++)
    {
        Max1 = max(Max1, dp_max[q][q + n - 1]);
        Min1 = min(Min1, dp_min[q][q + n - 1]);
    }
    cout << Min1<<endl <<  Max1;
    return 0;
}```