原题:
有 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堆石子。
石子合并问题可以用
d
p
[
i
]
[
j
]
dp[i][j]
dp[i][j]表示区间i到j这些石子合并后得到的最小决策值,如果是两个石子合并,那么在决策状态中,如果是在第k个位置寻找子区间。那么
d
p
[
i
]
[
k
]
+
d
p
[
k
+
1
]
[
j
]
+
f
u
n
(
i
,
j
,
k
)
dp[i][k]+dp[k+1][j]+fun(i,j,k)
dp[i][k]+dp[k+1][j]+fun(i,j,k)表示区间i到j石子两两合并所做的决策状态。
如果是三个石子呢?设置
d
p
[
i
]
[
j
]
dp[i][j]
dp[i][j]表示区间i到j之间三个石子三个石子合并得到的最优解。
同理可得
d
p
[
i
]
[
k
1
]
+
d
p
[
k
1
+
1
]
[
k
2
]
+
d
p
[
k
2
+
1
]
[
j
]
+
f
u
n
(
i
,
j
,
k
1
,
k
2
)
dp[i][k_1]+dp[k_1+1][k_2]+dp[k_2+1][j]+fun(i,j,k_1,k_2)
dp[i][k1]+dp[k1+1][k2]+dp[k2+1][j]+fun(i,j,k1,k2)
这里需要枚举
k
1
k_1
k1与
k
2
k_2
k2来寻找最优解
可想而知,如果是K很大的话,基本上没有办法做到对状态划分的枚举。
这里增加维度来表示区间i到j之间的状态,题目中限定了合并石子个数K为变量。
那么很容易想到设定状态
d
p
[
i
]
[
j
]
[
k
]
dp[i][j][k]
dp[i][j][k]来表示一个区间的石子合并后得到的最优值。
如果将上面的状态解释为在区间i到区间j使用连续k个石子合并规则得到的最优值会有一个问题,如何建立状态转移呢?即,如何从两个石子合并的状态得到三个石子合并的状态呢?很显然做不到。
换一种想法考虑
设置
d
p
[
i
]
[
j
]
[
k
]
dp[i][j][k]
dp[i][j][k]表示为将区间i到j的石子合并为k堆的最小代价
那么
d
p
[
i
]
[
j
]
[
k
]
=
m
i
n
(
d
p
[
i
]
[
x
]
[
k
−
1
]
+
d
p
[
x
+
1
]
[
j
]
[
1
]
)
dp[i][j][k]=min(dp[i][x][k-1]+dp[x+1][j][1])
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堆的情况。
合并的方式表现在状态转移的过程中,每次将得到的 d p [ i ] [ j ] [ K ] dp[i][j][K] dp[i][j][K]合并,得到将K堆石子合并后得到的最优值。
最后 d p [ i ] [ j ] [ 1 ] = m i n ( d p [ i ] [ j ] [ 1 ] , d p [ i ] [ j ] [ K ] + s u m [ j ] − s u m [ i − 1 ] ) dp[i][j][1] = min(dp[i][j][1], dp[i][j][K] + sum[j] - sum[i - 1]) dp[i][j][1]=min(dp[i][j][1],dp[i][j][K]+sum[j]−sum[i−1]) 表示把最后K堆石头合并成1堆。