leetcode 1000 合并石头的最低成本

原题：
有 N 堆石头排成一排，第 i 堆中有 stones[i] 块石头。

每次移动（move）需要将连续的 K 堆石头合并为一堆，而这个移动的成本为这 K 堆石头的总数。

找出把所有石头合并成一堆的最低成本。如果不可能，返回 -1 。

示例 1：

输入：stones = [3,2,4,1], K = 2
输出：20
解释：
从 [3, 2, 4, 1] 开始。
合并 [3, 2]，成本为 5，剩下 [5, 4, 1]。
合并 [4, 1]，成本为 5，剩下 [5, 5]。
合并 [5, 5]，成本为 10，剩下 [10]。
总成本 20，这是可能的最小值。

示例 2：

输入：stones = [3,2,4,1], K = 3
输出：-1
解释：任何合并操作后，都会剩下 2 堆，我们无法再进行合并。所以这项任务是不可能完成的。.

示例 3：

输入：stones = [3,5,1,2,6], K = 3
输出：25
解释：
从 [3, 5, 1, 2, 6] 开始。
合并 [5, 1, 2]，成本为 8，剩下 [3, 8, 6]。
合并 [3, 8, 6]，成本为 17，剩下 [17]。
总成本 25，这是可能的最小值。

提示：

1 <= stones.length <= 30
2 <= K <= 30
1 <= stones[i] <= 100

代码：

class Solution {
public:
    int dp[51][51][51];
    int mergeStones(vector<int>& stones, int K) 
    {
        int n = stones.size();
        if ((n - K) % (K - 1))
            return -1;
        vector<int> tmp(stones.size() + 1, 0);
        for (int i = 0; i < stones.size(); i++)
            tmp[i + 1] = stones[i];
        
        memset(dp, 0x3f, sizeof(dp));
        vector<int> sum(stones.size()+1,0);
        for (int i = 1; i <= n; i++)
        {
            dp[i][i][1] = 0;
            sum[i] = sum[i - 1] + tmp[i];
        }
        for (int len = 2; len <= n; len++)
        {
            for (int i = 1; i <= n - len + 1; i++)
            {
                int j = i + len - 1;
                for (int x = i; x < j; x++)
                {
                    for (int k = 2; k <= len; k++)
                    {
                        dp[i][j][k] = min(dp[i][j][k], dp[i][x][k - 1] + dp[x + 1][j][1]);
                    }
                }
                dp[i][j][1] = min(dp[i][j][1], dp[i][j][K] + sum[j] - sum[i - 1]);
            }
        }
        return dp[1][n][1];
    }
};

思路：

原始的石子合并问题是两个两个合并，此题多加了一个条件K，要求一次合并K堆石子。

石子合并问题可以用$dp[i][j]$表示区间i到j这些石子合并后得到的最小决策值，如果是两个石子合并，那么在决策状态中，如果是在第k个位置寻找子区间。那么
$dp[i][k]+dp[k+1][j]+fun(i,j,k)$表示区间i到j石子两两合并所做的决策状态。

如果是三个石子呢？设置$dp[i][j]$表示区间i到j之间三个石子三个石子合并得到的最优解。
同理可得
$dp[i][k_1]+dp[k_1+1][k_2]+dp[k_2+1][j]+fun(i,j,k_1,k_2)$
这里需要枚举$k_1$与$k_2$来寻找最优解

可想而知，如果是K很大的话，基本上没有办法做到对状态划分的枚举。

这里增加维度来表示区间i到j之间的状态，题目中限定了合并石子个数K为变量。
那么很容易想到设定状态$dp[i][j][k]$来表示一个区间的石子合并后得到的最优值。

如果将上面的状态解释为在区间i到区间j使用连续k个石子合并规则得到的最优值会有一个问题，如何建立状态转移呢？即，如何从两个石子合并的状态得到三个石子合并的状态呢？很显然做不到。

换一种想法考虑
设置$dp[i][j][k]$表示为将区间i到j的石子合并为k堆的最小代价
那么$dp[i][j][k]=min(dp[i][x][k-1]+dp[x+1][j][1])$即k-1堆石子与1堆石子合并得到k堆石子，可以实现递推操作，为什么是分成1 和k - 1而不是分成x和k - x堆是因为1 和 k - 1堆中的k - 1堆的情况在k - 1堆的继续递归的情况下已经跑含了其余的 k - x堆的情况。

合并的方式表现在状态转移的过程中，每次将得到的$dp[i][j][K]$合并，得到将K堆石子合并后得到的最优值。

最后$dp[i][j][1]=min(dp[i][j][1],dp[i][j][K]+sum[j]-sum[i-1])$ 表示把最后K堆石头合并成1堆。