代码拉取完成,页面将自动刷新
同步操作将从 doocs/leetcode 强制同步,此操作会覆盖自 Fork 仓库以来所做的任何修改,且无法恢复!!!
确定后同步将在后台操作,完成时将刷新页面,请耐心等待。
有一堆石头,用整数数组 stones
表示。其中 stones[i]
表示第 i
块石头的重量。
每一回合,从中选出任意两块石头,然后将它们一起粉碎。假设石头的重量分别为 x
和 y
,且 x <= y
。那么粉碎的可能结果如下:
x == y
,那么两块石头都会被完全粉碎;x != y
,那么重量为 x
的石头将会完全粉碎,而重量为 y
的石头新重量为 y-x
。最后,最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下,就返回 0
。
示例 1:
输入:stones = [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],这就是最优值。
示例 2:
输入:stones = [31,26,33,21,40] 输出:5
提示:
1 <= stones.length <= 30
1 <= stones[i] <= 100
方法一:动态规划
两个石头的重量越接近,粉碎后的新重量就越小。同样的,两堆石头的重量越接近,它们粉碎后的新重量也越小。
所以本题可以转换为,计算容量为 sum / 2
的背包最多能装多少重量的石头。
定义 dp[i][j]
表示从前 i 个石头中选出若干个,使得所选石头重量之和为不超过 j 的最大重量。
动态规划——0-1
背包朴素做法:
class Solution:
def lastStoneWeightII(self, stones: List[int]) -> int:
s = sum(stones)
m, n = len(stones), s >> 1
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(n + 1):
dp[i][j] = dp[i - 1][j]
if stones[i - 1] <= j:
dp[i][j] = max(
dp[i][j], dp[i - 1][j - stones[i - 1]] + stones[i - 1]
)
return s - 2 * dp[-1][-1]
动态规划——0-1
背包空间优化:
class Solution:
def lastStoneWeightII(self, stones: List[int]) -> int:
s = sum(stones)
m, n = len(stones), s >> 1
dp = [0] * (n + 1)
for v in stones:
for j in range(n, v - 1, -1):
dp[j] = max(dp[j], dp[j - v] + v)
return s - dp[-1] * 2
class Solution {
public int lastStoneWeightII(int[] stones) {
int s = 0;
for (int v : stones) {
s += v;
}
int m = stones.length;
int n = s >> 1;
int[][] dp = new int[m + 1][n + 1];
for (int i = 1; i <= m; ++i) {
for (int j = 0; j <= n; ++j) {
dp[i][j] = dp[i - 1][j];
if (stones[i - 1] <= j) {
dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - stones[i - 1]] + stones[i - 1]);
}
}
}
return s - dp[m][n] * 2;
}
}
class Solution {
public int lastStoneWeightII(int[] stones) {
int s = 0;
for (int v : stones) {
s += v;
}
int m = stones.length;
int n = s >> 1;
int[] dp = new int[n + 1];
for (int v : stones) {
for (int j = n; j >= v; --j) {
dp[j] = Math.max(dp[j], dp[j - v] + v);
}
}
return s - dp[n] * 2;
}
}
class Solution {
public:
int lastStoneWeightII(vector<int>& stones) {
int s = accumulate(stones.begin(), stones.end(), 0);
int m = stones.size(), n = s >> 1;
vector<vector<int>> dp(m + 1, vector<int>(n + 1));
for (int i = 1; i <= m; ++i) {
for (int j = 0; j <= n; ++j) {
dp[i][j] = dp[i - 1][j];
if (stones[i - 1] <= j) dp[i][j] = max(dp[i][j], dp[i - 1][j - stones[i - 1]] + stones[i - 1]);
}
}
return s - dp[m][n] * 2;
}
};
class Solution {
public:
int lastStoneWeightII(vector<int>& stones) {
int s = accumulate(stones.begin(), stones.end(), 0);
int n = s >> 1;
vector<int> dp(n + 1);
for (int& v : stones)
for (int j = n; j >= v; --j)
dp[j] = max(dp[j], dp[j - v] + v);
return s - dp[n] * 2;
}
};
impl Solution {
#[allow(dead_code)]
pub fn last_stone_weight_ii(stones: Vec<i32>) -> i32 {
let n = stones.len();
let mut sum = 0;
for e in &stones {
sum += *e;
}
let m = (sum / 2) as usize;
let mut dp: Vec<Vec<i32>> = vec![vec![0; m + 1]; n + 1];
// Begin the actual dp process
for i in 1..=n {
for j in 1..=m {
dp[i][j] = if stones[i - 1] > j as i32 {
dp[i - 1][j]
} else {
std::cmp::max(dp[i - 1][j], dp[i - 1][j - stones[i - 1] as usize] + stones[i - 1])
};
}
}
sum - 2 * dp[n][m]
}
}
func lastStoneWeightII(stones []int) int {
s := 0
for _, v := range stones {
s += v
}
m, n := len(stones), s>>1
dp := make([][]int, m+1)
for i := range dp {
dp[i] = make([]int, n+1)
}
for i := 1; i <= m; i++ {
for j := 0; j <= n; j++ {
dp[i][j] = dp[i-1][j]
if stones[i-1] <= j {
dp[i][j] = max(dp[i][j], dp[i-1][j-stones[i-1]]+stones[i-1])
}
}
}
return s - dp[m][n]*2
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
func lastStoneWeightII(stones []int) int {
s := 0
for _, v := range stones {
s += v
}
n := s >> 1
dp := make([]int, n+1)
for _, v := range stones {
for j := n; j >= v; j-- {
dp[j] = max(dp[j], dp[j-v]+v)
}
}
return s - dp[n]*2
}
func max(a, b int) int {
if a > b {
return a
}
return b
}
/**
* @param {number[]} stones
* @return {number}
*/
var lastStoneWeightII = function (stones) {
let s = 0;
for (let v of stones) {
s += v;
}
const n = s >> 1;
let dp = new Array(n + 1).fill(0);
for (let v of stones) {
for (let j = n; j >= v; --j) {
dp[j] = Math.max(dp[j], dp[j - v] + v);
}
}
return s - dp[n] * 2;
};
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。