代码随想录笔记_动态规划_1049最后一块石头的重量II

代码随想录二刷笔记记录

LC1049.最后一块石头的重量II

---

题目

01背包

有一堆石头，每块石头的重量都是正整数。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎； 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。 最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

示例： 输入：[2,7,4,1,8,1] 输出：1 解释： 组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]， 组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]， 组合 2 和 1，得到 1，所以数组转化为 [1,1,1]， 组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。

提示：

• 1 <= stones.length <= 30
• 1 <= stones[i] <= 1000

---

思路分析

思路：
由题可发现,尽量让石头分成相同重量的两堆，相撞之后，剩下的石头最小。

转化为01背包问题。本题类似LC416分割等和子集。区别仅在于返回值的不同.

01背包的概念

1.背包的容量 sum/2
2.背包需要放入的商品重量为元素的数值stone[i],价值也是stone[i]
3.背包如果正好装满,代表找到了所需的子集
4.背包中的每一个石头都是只取一次

动态规划五部曲

1.确定dp数组及其下标含义

dp[j]:表示容量j的背包内,能装下的石头总价值.

2.确定递推公式

回顾01背包的递推公式
dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

递推公式如下
dp[j] = max(dp[j],dp[j - stone[i]] + stone[i]);

3.初始化

题目中指出 1 <= stone.length <= 30, 1 <= stone[i] <= 100，可知，stone最重可达到30*100 = 30000, dp数组最大的size则取 30000/2 = 15000 即可。

在代码实现中，我是根据具体的 stone 数组sum的大小初始化 dp 的 size。
由于stone元素都大于0，因此初始化为0即可。

4.遍历顺序

for(int i = 0; i < stones.length;i++){//遍历石头
	for(int j = target; j >= stones[i];j--){//遍历背包容量
		//只放一次,采用倒序
		dp[j] = max(dp[j],dp[j - stones[i]] + stones[i]);
	}
}

5.推演分析

以[1,1,2,4,7,8] 为例,sum=23

容量 j	0	1	2	3	4	5	6	7	8	9	10	11
stones[0]	0	1	1	1	1	1	1	1	1	1	1	1
stones[1]	0	1	2	2	2	2	2	2	2	2	2	2
stones[2]	0	1	2	3	4	4	4	4	4	4	4	4
stones[3]	0	1	2	3	4	5	6	7	8	8	8	8
stones[3]	0	1	2	3	4	5	6	7	8	9	10	11

图示:

---

代码实现

完整代码实现

public int lastStoneWeightII(int[] stones) {
        if(null == stones || stones.length == 0) return 0;
        int sum = 0;
        for(int stone: stones){
            sum += stone;
        }
        int target = sum/2;//要让差值小,两堆石头的重量都要接近sum/2
        int[] dp = new int[target+1];
        //遍历顺序
        for(int i = 0; i < stones.length;i++){//遍历石头
            for(int j = target; j >= stones[i];j--){//遍历背包容量
                //只放一次,采用倒序
                dp[j] = Math.max(dp[j],dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - dp[target] - dp[target];
    }

---