19182 石子合并（基础版）

解决这个问题的关键是使用区间动态规划。我们可以定义一个二维数组 `dp[i][j]` 来表示将第 `i` 堆到第 `j` 堆石子合并成一堆的最小代价。为了计算这些代价，我们还需要一个辅助数组 `sum[i]` 来存储前 `i` 堆石子的总质量，这样可以快速计算任意一段区间的石子总质量。

### 算法步骤
1. 初始化 `sum` 数组，`sum[i] = sum[i-1] + mi`，其中 `mi` 是第 `i` 堆石子的质量。
2. 初始化 `dp[i][i] = 0`，因为单独一堆石子不需要合并，代价为0。
3. 使用三重循环来填充 `dp` 数组：
   - 外层循环 `len` 从2开始，表示合并区间的长度，一直到 `N`。
   - 中层循环 `i` 表示区间的起始点，`j = i + len - 1` 表示区间的终点。
   - 内层循环 `k` 用于尝试所有可能的分割点，`dp[i][j]` 可以通过合并 `dp[i][k]` 和 `dp[k+1][j]` 的最小值加上合并这两部分的代价来计算。
4. 最终 `dp[1][N]` 就是合并全部石子的最小代价。

### 代码实现

#include <iostream>
#include <vector>

using namespace std;

const int MAX_COST = 300001; // Define our own maximum cost

int main() {
    int N;
    cin >> N;
    vector<int> m(N+1), sum(N+1, 0);
    vector<vector<int>> dp(N+1, vector<int>(N+1, 0));

    for (int i = 1; i <= N; ++i) {
        cin >> m[i];
        sum[i] = sum[i-1] + m[i];
    }

    for (int len = 2; len <= N; ++len) {
        for (int i = 1; i <= N - len + 1; ++i) {
            int j = i + len - 1;
            dp[i][j] = MAX_COST;
            for (int k = i; k < j; ++k) {
                int cost = dp[i][k] + dp[k+1][j] + sum[j] - sum[i-1];
                dp[i][j] = (dp[i][j] > cost) ? cost : dp[i][j]; // Replace min function
            }
        }
    }

    cout << dp[1][N] << endl;

    return 0;
}

这段代码首先读取输入，然后计算每个可能的合并区间的最小代价，并存储在 `dp` 数组中。最后输出合并全部石子的最小代价。