一、题目
有一堆石头,用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。
每一回合,从中选出任意两块石头,然后将它们一起粉碎。假设石头的重量分别为 x 和 y,且 x <= y。那么粉碎的可能结果如下:
- 如果 x == y,那么两块石头都会被完全粉碎;
- 如果 x != y,那么重量为 x 的石头将会完全粉碎,而重量为 y 的石头新重量为 y-x。
最后,最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下,就返回 0。
二、思路
1)动态规划
题目很迷惑人,首先手动模拟一下,如果分为两堆A和B,假设sum(A)>sum(B),每次操作剩下的,放回原来的堆里面,那么两堆最后的结果一定为diff=sum(A)-sum(B)。(这里自行理解一下)
那么本题也就转换为找到最相近的两堆A和B,假设所有石头重量和为sum,那么需要找到小于等于sum/2的一堆石头,也就转化为了01背包问题。
使用二维数组dp[i][j],代表前i个石头组成重量为j的方法,其值为true或false。可以得到状态转移方程:
d
p
[
i
]
[
j
]
=
{
d
p
[
i
−
1
]
[
j
]
j
<
s
t
o
n
e
s
[
i
−
1
]
d
p
[
i
−
1
]
[
j
]
∣
∣
d
p
[
i
−
1
]
[
j
−
s
t
o
n
e
s
[
i
−
1
]
]
j
>
=
s
t
o
n
e
s
[
i
−
1
]
dp[i][j]= \left\{\begin{matrix} dp[i-1][j]&&j<stones[i-1]\\ dp[i-1][j]~||~dp[i-1][j-stones[i-1]]&&j>=stones[i-1] \end{matrix}\right.
dp[i][j]={dp[i−1][j]dp[i−1][j] ∣∣ dp[i−1][j−stones[i−1]]j<stones[i−1]j>=stones[i−1]
最后,在dp数组的最后一行遍历,找到能够生成的最大重量(<=sum/2)的方案loc,那么最小重量就为sum-2*loc
2)优化
跟经典的01背包问题一样,由于dp[i][j]只依赖于i-1行的状态,可以压缩为一维数组
由于使用一维数组可以直接继承上一行状态,减少了j<stones[i-1]的时间,提升程序运行速度
三、代码
1)动态规划
class Solution {
public int lastStoneWeightII(int[] stones) {
int sum = 0;
for (int stone : stones) {
sum += stone;
}
boolean[][] dp = new boolean[stones.length + 1][sum/2 + 1];
dp[0][0] = true;
for (int i = 1; i < dp.length; i++) {
for (int j = 0; j < dp[0].length; j++) {
dp[i][j] = dp[i-1][j];
if (j >= stones[i-1]) {
dp[i][j] = dp[i-1][j] || dp[i-1][j-stones[i-1]];
}
}
}
int loc = dp[0].length - 1;
while (dp[stones.length][loc] == false) {
loc--;
}
return sum - 2*loc;
}
}
时间复杂度为O(stones.length*(sum/2)),空间复杂度为O(stones.length*(sum/2))
2)优化
class Solution {
public int lastStoneWeightII(int[] stones) {
int sum = 0;
for (int stone : stones) {
sum += stone;
}
boolean[] dp = new boolean[sum/2 + 1];
dp[0] = true;
for (int i = 0; i < stones.length; i++) {
for (int j = dp.length-1; j >= stones[i]; j--) {
dp[j] = dp[j] || dp[j-stones[i]];
}
}
int loc = dp.length - 1;
while (dp[loc] == false) {
loc--;
}
return sum - 2*loc;
}
}
时间复杂度为O(stones.length*(sum/2)),空间复杂度为O(sum/2)