石子合并（算法竞赛进阶指南）

设有 N 堆石子排成一排，其编号为 1，2，3，…，N。

每堆石子有一定的质量，可以用一个整数来描述，现在要将这 N 堆石子合并成为一堆。

每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。

例如有 4 堆石子分别为 1 3 5 2， 我们可以先合并 1、2 堆，代价为 4，得到 4 5 2， 又合并 1，2 堆，代价为 9，得到 9 2 ，再合并得到 11，总代价为 4+9+11=24；

如果第二步是先合并 2，3 堆，则代价为 7，得到 4 7，最后一次合并代价为 11，总代价为 4+7+11=22。

问题是：找出一种合理的方法，使总的代价最小，输出最小代价。

输入格式

第一行一个数 N 表示石子的堆数 N。

第二行 N 个数，表示每堆石子的质量(均不超过 1000)。

输出格式

输出一个整数，表示最小代价。

数据范围

1≤N≤300

输入样例：

4

1 3 5 2

输出样例：

22

这道题有明显的转移趋势。我们需要维护的是一个区间的某个属性。

区间DP的特点：

1.状态确立时往往表示为（f[i][j]）从第i个到第j个中**的值最大（最小）

2.状态转移往往都是，f[i][j] = f[i + 1][j] + w[i],f[i][j] = f[i][j - 1] + w[j].

在本题中：

1.状态确立

f[i][j]表示合并从i到j石子的最小代价。

2.状态转移

f[i][j] = min(f[i][k] + f[k + 1][j] + w[i][j],f[i][j])

3.注意事项

1.在本题中，w[i][j]用前缀和表示：s[j] - s[i - 1].

2.区间DP的枚举要注意顺序。我们要确立这个区间的长度，其次是区间的起点，而后区间的重点自然可以用i + len - 1得出。因为我们在状态转移的过程中，区间长度大的状态往往用区间长度小的状态更新（比如本题），所以我们枚举时，区间的长度是第一要素。

3.当len = 1时，即i = j 时，我们一般进行初始化。

代码：

#include<bits/stdc++.h>
using namespace std;
const int N = 301;
int n;
long long f[N][N],s[N];
int m[N];
int main()
{
    cin >> n;
    for(int i = 1;i <= n;i ++)
    {
        int w;
        cin >> w;
        s[i] = s[i - 1] + w;
    }
    memset(f,0x3f,sizeof f);
    for(int len = 1;len <= n;len ++)
        for(int i = 1;i + len - 1 <= n;i ++)
        {
            int j = i + len - 1;
            if(len == 1)
            {
                f[i][j] = 0;
                continue;
            }
            for(int k = i;k < j;k ++)//k必须从i开始而不是i + 1
            {
                f[i][j] = min(f[i][k] + f[k + 1][j] + s[j] - s[i - 1],f[i][j]);
            }
        }
    cout << f[1][n];
    return 0;
}