【leetcode 4.4每日一题】1000.合并石头的最低成本 图解及代码（C++）

勤学苦练终成才，刻苦钻研谱人生.

题目🥞

有 N 堆石头排成一排，第 i 堆中有 stones[i] 块石头。
每次移动（move）需要将连续的 K 堆石头合并为一堆，而这个移动的成本为这 K 堆石头的总数。
找出把所有石头合并成一堆的最低成本。如果不可能，返回 -1 。

解析🥖

引入动态规划🍔

首先看到这道题，有经验的同学应该就会有点眼熟。每次将k个堆合成一堆，最后剩下一堆。。。是不是觉得和某个算法有点像？如果还没想出来，没关系，看看下面的图，相信你会想起来的。
这是一个k=2时的合并方案。
一拍脑门，这不就是分治算法的逆过程嘛！然后由分治，就能联想到递推，最后想到动态规划。OK，这道题的大致方向已经出来了。

这里可以做个小笔记：当同一个过程不断重复，且后面过程的输入是前面过程的输出时，这道题的一个主要考点一定是递推。

动态规划嘛，只要找到转移方程，剩下的都不过是套路了。那么这个转移方程怎么找呢？

寻找转移方程🍄

在上面的图中，我们每次选择两堆合并，不难看出，k=2时的转移方程为d[l][r]=d[l][p]+d[p+1][r]，其中我们以p为分界线，p之前的先并成一堆，p之后的再并成一堆，然后将这两堆合并。
那么问题来了，k如果大于2，比如说，k=3怎么办？我们看下面这张图。
这是当k=3时，最后一次合并的情况。思考一下，从2到3，什么东西变化了？很容易就能看出来吧？对啊，增加了一堆嘛！3=2+1嘛。那么，如果说，我们把一堆先堆出来，那剩下的2堆不就可以变成上面的问题了嘛！

那k=4呢？4=2+1+1，所以一样的，先堆出来一堆，剩下的3堆再堆出来一堆，最后还是剩下2堆。
我们扩展到k任意的情况。这时候，我们在每一步都需要先堆出来一堆，然后再处理剩下的堆。
其实，k=2的时候，我们也是先堆出来一堆，然后再堆出来另外一堆的。
解释到这里，那么官方题解中的转移方程就好解释了。贴一下官方的转移方程：

初态：对于所有的 d[i][i][1]，初始化为 0，其他状态设置为正无穷。
转移方程：
当 t=1时，d[l][r][t]=d[l][r][k]+sum[l][r]，其中 sum[l][r]是本次合并的成本，区间内石头的总数。
否则，d[l][r][t]=min⁡{d[l][p][1]+d[p+1][r][t−1]}，其中 l≤p<r。
目标：d[0][n−1][1]。

这里的t指的就是到某一步的时候，要分成多少堆了。
用一个式子概括，就是

1+1+1+1…+1=2+1+1…+1=3+1+…+1=…=t-1+1=t；

最后就是代码了，说实话，我觉得掌握了思路，代码怎么写不是很重要（绝不是不重要！），贴一下官方代码。由于是按递推的思路讲的，所以贴一下递推代码，大家看一看：

class Solution {
    static constexpr int inf = 0x3f3f3f3f;
public:
    int mergeStones(vector<int>& stones, int k) {
        int n = stones.size();
        if ((n - 1) % (k - 1) != 0) {
            return -1;
        }

        vector d(n, vector(n, vector<int>(k + 1, inf)));
        vector<int> sum(n, 0);

        for (int i = 0, s = 0; i < n; i++) {
            d[i][i][1] = 0;
            s += stones[i];
            sum[i] = s;
        }

        for (int len = 2; len <= n; len++) {
            for (int l = 0; l < n && l + len - 1 < n; l++) {
                int r = l + len - 1;
                for (int t = 2; t <= k; t++) {
                    for (int p = l; p < r; p += k - 1) {
                        d[l][r][t] = min(d[l][r][t], d[l][p][1] + d[p + 1][r][t - 1]);\\转移方程
                    }
                }
                d[l][r][1] = min(d[l][r][1], d[l][r][k] + 
                                sum[r] - (l == 0 ? 0 : sum[l - 1]));\\最后合的时候别忘了加上所有石头的成本
            }
        }
        return d[0][n - 1][1];
    }
};

最后讲一下方法二。方法二其实就是方法一的一个小优化，由于每一次合并会减少k-1堆，所以给定l和r，t的数目其实是固定的。也就是说，t和l，r这两个变量是有关系的。因此写转移方程时可以省掉一个维度。但核心思想是不变的，都是先拆出来一堆，然后再去处理另外一堆。上官方代码：

class Solution {
    static constexpr int inf = 0x3f3f3f3f;
public:
    int mergeStones(vector<int>& stones, int k) {
        int n = stones.size();
        if ((n - 1) % (k - 1) != 0) {
            return -1;
        }

        vector d(n, vector<int>(n, inf));
        vector<int> sum(n, 0);

        for (int i = 0, s = 0; i < n; i++) {
            d[i][i] = 0;
            s += stones[i];
            sum[i] = s;
        }

        for (int len = 2; len <= n; len++) {
            for (int l = 0; l < n && l + len - 1 < n; l++) {
                int r = l + len - 1;
                for (int p = l; p < r; p += k - 1) {
                    d[l][r] = min(d[l][r], d[l][p] + d[p + 1][r]);
                }
                if ((r - l) % (k - 1) == 0) {
                    d[l][r] += sum[r] - (l == 0 ? 0 : sum[l - 1]);
                }
            }
        }
        return d[0][n - 1];
    }
};

我是霜_哀，在算法之路上努力前行的一位萌新，感谢你的阅读！如果觉得好的话，可以关注一下，我会在将来带来更多更全面的算法讲解！