摘要：本文将对LeetCode原题合并石头的最低成本进行介绍，思路基于动态规划，设计到状态的设计和优化，实现基于golang语言实现，并且已经通过所有测试用例，每一种方法都将给出复杂度分析。
关键词：LeetCode，golang，动态规划

原题描述

LeetCode 1000 合并石头的最低成本：有n堆石头，每次可以将连续k堆石头合并成一堆，代价是连续k堆石头的石头总数，现在需要将这n堆石头合并成一堆，求合成的最低成本。

方法一、动态规划

思路简述

十分经典的动态规划题目，问题是n堆石头合并成一堆，可以这样去做，可以先将所有石头合并成k堆，然后再进行最后一次合并。如何将所有石头合并成k堆，可以先将前面的一部分合并成一堆，后面的一部分合并成k-1堆。显然，无论是前面的一部分合并成一堆，还是后面的一部分合并成k-1堆，都是原来大问题下的一个子问题。因此，可以基于动态规划实现，定义dp[i][j][k]表示为将stones[i:j+1]合并成k+1堆的最低成本，那么最终要返回的答案就是dp[0][n-1][0]。
在实现上，选择的正无穷大为0x3f3f3f3f，当然选择其他数也可以，初始时，除了dp[i][i][0]赋值为0外，剩余所有值赋值为inf。对于递推过程，需要注意，要从较小的区间往较大的区间的顺序去递推。具体过程参考以下实现代码。

代码实现

var inf int = 0x3f3f3f3f

func mergeStones(stones []int, k int) int {
	n := len(stones)
	if n == 1 {
		return 0
	}
	if k > n || (n-1)%(k-1) != 0 {
		return -1
	}
	prefixSum := make([]int, n+1)
	sum := 0
	dp := make([][][]int, n)
	for i := 0; i < n; i++ {
		dp[i] = make([][]int, n)
		for j := 0; j < n; j++ {
			// dp[i][j][k]将stones[i: j+1]合并为k堆的最小代价
			dp[i][j] = make([]int, k)
			for p := 0; p < k; p++ {
				dp[i][j][p] = inf
			}
		} 
		dp[i][i][0] = 0
		sum += stones[i]
		prefixSum[i+1] = sum
	}

	for len := 2; len <= n; len++ {   // 区间长度遍历
		for l := 0; l < n - len + 1; l++ {   // 区间左端点遍历
			r := l + len - 1   // 右端点计算
			for p := 1; p < k; p++ {   // 区间分为多少堆枚举
				for q := l; q < r; q++ {   // 中间点枚举
					dp[l][r][p] = min(dp[l][r][p], dp[l][q][0] + dp[q + 1][r][p - 1])
				}
			}
			dp[l][r][0] = min(dp[l][r][0], dp[l][r][k - 1] + prefixSum[r + 1] - prefixSum[l])
		}
	}
	ans := dp[0][n - 1][0]
	if ans >= inf {
		return -1
	}
	return ans
}

LeetCode运行截图如下：

复杂度分析

• 时间复杂度：$O(n^{3}k)$
• 空间复杂度：$O(n^{2}k)$

方法二、动态规划（状态优化）

思路简述

考虑如何优化上面的思路，对于一个区间[l: r]来说，实际上，其最终能够不断合并到的堆数是固定的，所以对于（区间左端点，区间右端点，区间合并后堆数）中的区间合并后堆数是可以省略的，这样就能够将时间复杂度优化到$O(n^3)$。

代码实现

func mergeStonesV1(stones []int, k int) int {
	n := len(stones)
	if n == 1 {
		return 0
	}
	if k > n || (n-1)%(k-1) != 0 {
		return -1
	}
	prefixSum := make([]int, n+1)
	sum := 0
	dp := make([][]int, n)
	for i := 0; i < n; i++ {
		dp[i] = make([]int, n)
		for j := 0; j < n; j++ {
			dp[i][j] = inf
		} 
		dp[i][i] = 0
		sum += stones[i]
		prefixSum[i+1] = sum
	}
	for len := 2; len <= n; len++ {   // 区间长度遍历
		for L := 0; L < n - len + 1; L++ {   // 区间左端点遍历
			R := L + len - 1   // 右端点计算
			for q := L; q < R; q += (k - 1) {   // 中间点枚举
				dp[L][R] = min(dp[L][R], dp[L][q] + dp[q + 1][R])
			}
			if (R - L) % (k - 1) == 0 {
				dp[L][R] += (prefixSum[R + 1] - prefixSum[L])
			}
			fmt.Printf("%d-%d-%d\n", L, R, dp[L][R])
		}
	}
	ans := dp[0][n - 1]
	if ans >= inf {
		return -1
	}
	return ans
}

LeetCode运行截图如下：

复杂度分析

• 时间复杂度：$O(n^3)$
• 空间复杂度：$O(n^2)$

参考

• 合并石头的最低成本