石子合并（区间DP）

题目描述

设有 $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问题。

既然是DP首先需要考虑的状态表示，对于该问题，其状态表示为f[i][j]：将区间i~j的石子合并起来的最小代价。

然后再考虑状态转移，由于每次新的一堆石子只能由左右相邻的两堆合并而来，那么对于[i~j]的石子堆，它只能由左边的石子堆f[i][k]以及右边的石子堆f[k + 1][j]合并而来，而这个左、右堆的范围具体划定为多大不清楚，所以需要枚举，那么由此得到了该问题的状态转移方程为：

for k in (i, j) : $f[i][j]=min(f[i][j],f[i][k]+f[k+1][j]+i～j这段区间的石子重量和)$。

而为了方便快速地计算i～j这段区间的石子重量和，考虑使用前缀和数组s，从而由s[j] - s[i - 1]即可得出，在读数据
时便维护前缀和。

最终，输出f[1][n]即为本问题的全局解。

---

C++代码

#include <iostream>
#include <algorithm>
using namespace std;

const int N = 310;

int s[N], f[N][N];      //f[i][j]表示范围石子编号i～j中合并石子的最小代价
int n;

int main(){
    cin >> n;
    for(int i = 1;i <= n;i ++){     //计算前缀和，方便后面计算i～j内石子的合并代价
        int t;
        cin >> t;
        s[i] = t + s[i - 1];
    }
    
    //len为2、3、4...n的窗口[i,j]慢慢滑动来维护f[][]
    for(int len = 2;len <= n;len ++)        
        for(int i = 1;i + len - 1 <= n;i ++){
            int j = i + len - 1;
            
            f[i][j] = 0x3f3f3f;
            for(int k = i;k < j;k ++)       
                /**
                * 将i～k、k + 1～j这两堆合并起来的代价是s[j] - s[i - 1]
                * f[i][k] + f[k + 1][j]是前面分别在合并这两堆时积累的代价
                */
                f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j] + s[j] - s[i - 1]);
        }
    
    cout << f[1][n] << endl;
    return 0;
}