代码随想录Day 36|滑铁卢了,leetcode题目：1049.最后一块石头的重量、494.目标和、474.一和零

最新推荐文章于 2024-10-12 17:26:00 发布
最新推荐文章于 2024-10-12 17:26:00 发布
阅读量1.1k 收藏 8
点赞数 28
文章标签： leetcode 算法 职场和发展 数据结构 人工智能 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LuckyYH__/article/details/141979655
版权

提示：DDU，供自己复习使用。欢迎大家前来讨论~

文章目录

动态规划

有点难了，之前差的有点多，找时间补

一、题目

题目一：1049.最后一块石头的重量II

leetcode题目链接

解题思路：

本题：

想象一下，你有一堆苹果，你要把它们分成两堆，使得这两堆苹果的总数尽可能接近。但是，你每次只能从这堆苹果里拿出两个来，然后放一个苹果回去，这个新放回去的苹果是那两个苹果的重量差。这个过程重复进行，直到你不能再拿出两个苹果为止。

现在，我们一步步来看这个过程：

  1. 开始：你有一堆苹果，比如【31, 26, 33, 21, 40】。

  2. 第一次比较：你拿出最重的两个苹果，40和21，它们的重量差是19，你把这个重量差19放回去，苹果堆变成了【19, 26, 31, 33】。

  3. 第二次比较：你再拿出两个苹果，比如31和19，它们的重量差是12，你把这个重量差12放回去，苹果堆变成了【12, 26, 33】。

  4. 第三次比较：你继续拿出两个苹果，比如33和12，它们的重量差是21，你把这个重量差21放回去，苹果堆变成了【21, 26】。

  5. 第四次比较：现在你只有两个苹果了，你拿出26和21，它们的重量差是5，你把这个重量差5放回去，苹果堆变成了。

  6. 结束：现在你只剩下一个苹果了，这个过程就结束了。这个最后的苹果重量5，就是两堆苹果重量差的最小值。

  7. 分组：回头看，你实际上是在尝试找到两堆苹果，一堆是【31, 26, 21】，另一堆是【40, 33】。这两堆苹果的总重量分别是78和74，它们的差值就是4，这是你通过比较苹果重量差得到的结果。

  8. 找平衡：这个过程就像是在找两堆苹果，让它们的总重量尽可能接近。这就像是你有一个天平，你想要两边放的苹果重量差不多，这样天平才能平衡。

所以，通过两两比较苹果的重量差，你实际上是在尝试找到两堆苹果，让它们的总重量尽可能接近。这个过程就像是在解决一个找平衡的问题，也就是我们说的01背包问题。这个问题的关键是找到一种方法，让两堆苹果的总重量尽可能接近，这样天平才能平衡。

本题物品的重量为stones[i]，物品的价值也为stones[i]。

对应着01背包里的物品重量weight[i]和 物品价值value[i]。

接下来进行动规五步曲：

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

dp[j]表示容量（这里说容量更形象，其实就是重量）为j的背包，最多可以背最大重量为dp[j]。

可以回忆一下01背包中，dp[j]的含义，容量为j的背包，最多可以装的价值为 dp[j]。

相对于 01背包，本题中，石头的重量是 stones[i]，石头的价值也是 stones[i] ，可以 “最多可以装的价值为 dp[j]” == “最多可以背的重量为dp[j]”

  1. 确定递推公式

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

本题则是：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);

  1. dp数组如何初始化

既然 dp[j]中的j表示容量，那么最大容量（重量）是多少呢，就是所有石头的重量和。

因为提示中给出1 <= stones.length <= 30，1 <= stones[i] <= 1000，所以最大重量就是30 * 1000 。

而我们要求的target其实只是最大重量的一半，所以dp数组开到15000大小就可以了。

当然也可以把石头遍历一遍，计算出石头总重量 然后除2，得到dp数组的大小。

这里就直接用15000了。

接下来就是如何初始化dp[j]呢，因为重量都不会是负数，所以dp[j]都初始化为0就可以了，这样在递归公式dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);中dp[j]才不会初始值所覆盖。

代码为：

vector<int> dp(15001, 0);
  1. 确定遍历顺序

如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！

代码如下：

for (int i = 0; i < stones.size(); i++) { // 遍历物品
    for (int j = target; j >= stones[i]; j--) { // 遍历背包
        dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
    }
}
  1. 举例推导dp数组

举例，输入：[2,4,1,1]，此时target = (2 + 4 + 1 + 1)/2 = 4 ，dp数组状态图如下：

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

最后dp[target]里是容量为target的背包所能背的最大重量。

那么分成两堆石头，一堆石头的总重量是dp[target]，另一堆就是sum - dp[target]。

在计算target的时候，target = sum / 2 因为是向下取整，所以sum - dp[target] 一定是大于等于dp[target]的。

那么相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]。

以上分析完毕，C++代码如下：

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        vector<int> dp(15001, 0);
        int sum = 0;
        for (int i = 0; i < stones.size(); i++) sum += stones[i];
        int target = sum / 2;
        for (int i = 0; i < stones.size(); i++) { // 遍历物品
            for (int j = target; j >= stones[i]; j--) { // 遍历背包
                dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - dp[target] - dp[target];
    }
};
  • 时间复杂度：O(m × n) , m是石头总重量（准确的说是总重量的一半），n为石头块数
  • 空间复杂度：O(m

题目二：494.目标和

动态规划 （二维dp数组）

假设加法的总和为x，那么减法对应的总和就是sum - x。

所以我们要求的是 x - (sum - x) = target

x = (target + sum) / 2

此时问题就转化为，装满容量为x的背包，有几种方法。

这里的x，就是bagSize，也就是我们后面要求的背包容量。

大家看到(target + sum) / 2 应该担心计算的过程中向下取整有没有影响。

这么担心就对了，例如sum是5，target是2 的话其实就是无解的，所以：

（C++代码中，输入的S 就是题目描述的 target）
if ((target + sum) % 2 == 1) return 0; // 此时没有方案

同时如果target 的绝对值已经大于sum，那么也是没有方案的。

if (abs(target) > sum) return 0; // 此时没有方案

因为每个物品（题目中的1）只用一次！

这次和之前遇到的背包问题不一样了，之前都是求容量为j的背包，最多能装多少。

本题则是装满有几种方法。其实这就是一个组合问题了。

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

先用 二维 dp数组求解本题，dp[i][j]：使用 下标为[0, i]的nums[i]能够凑满j（包括j）这么大容量的包，有dp[i][j]种方法。

  1. 确定递推公式

先手动推导一下，这个二维数组里面的数值。

先只考虑物品0，如图：

img

（这里的所有物品，都是题目中的数字1）。

装满背包容量为0 的方法个数是1，即 放0件物品。

装满背包容量为1 的方法个数是1，即 放物品0。

装满背包容量为2 的方法个数是0，目前没有办法能装满容量为2的背包。

接下来 考虑 物品0 和 物品1，如图：

img

装满背包容量为0 的方法个数是1，即 放0件物品。

装满背包容量为1 的方法个数是2，即 放物品0 或者 放物品1。

装满背包容量为2 的方法个数是1，即 放物品0 和 放物品1。

其他容量都不能装满，所以方法是0。

接下来 考虑 物品0 、物品1 和 物品2 ，如图：

img

装满背包容量为0 的方法个数是1，即 放0件物品。

装满背包容量为1 的方法个数是3，即 放物品0 或者 放物品1 或者 放物品2。

装满背包容量为2 的方法个数是3，即 放物品0 和 放物品1、放物品0 和 物品 2、 放物品1 和 物品2。

装满背包容量为3的方法个数是1，即 放物品0 和 物品1 和 物品2。

通过以上举例，我们来看 dp[2][2] 可以有哪些方向推出来。

如图红色部分：

img

dp[2][2] = 3，即 放物品0 和 放物品1、放物品0 和 物品 2、放物品1 和 物品2， 如图所示，三种方法：

img

容量为2 的背包，如果不放 物品2 有几种方法呢？

有 dp[1][2] 种方法，即 背包容量为2，只考虑物品0 和 物品1 ，有 dp[1][2] 种方法，如图：

img

容量为2 的背包， 如果放 物品2 有几种方法呢？

首先 要在背包里 先把物品2的容量空出来， 装满 刨除物品2容量 的背包 有几种方法呢？

刨除物品2容量后的背包容量为 1。

此时装满背包容量为1 有 dp[1][1] 种方法，即： 不放物品2，背包容量为1，只考虑物品 0 和 物品 1，有 dp[1][1] 种方法。

如图：

img

有录友可能疑惑，这里计算的是放满 容量为2的背包 有几种方法，那物品2去哪了？

在上面图中，你把物品2补上就好，同样是两种方法。

dp[2][2] = 容量为2的背包不放物品2有几种方法 + 容量为2的背包不放物品2有几种方法

所以 dp[2][2] = dp[1][2] + dp[1][1] ，如图：

img

以上过程，抽象化如下：

  • 不放物品i：即背包容量为j，里面不放物品i，装满有dp[i - 1][j]中方法。
  • 放物品i： 即：先空出物品i的容量，背包容量为（j - 物品i容量），放满背包有 dp[i - 1][j - 物品i容量] 种方法。

本题中，物品i的容量是nums[i]，价值也是nums[i]。

递推公式：dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];

考到这个递推公式，我们应该注意到，j - nums[i] 作为数组下标，如果 j - nums[i] 小于零呢？

说明背包容量装不下 物品i，所以此时装满背包的方法值 等于 不放物品i的装满背包的方法，即：dp[i][j] = dp[i - 1][j];

所以递推公式：

if (nums[i] > j) dp[i][j] = dp[i - 1][j]; 
else dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];

1
2

  1. dp数组如何初始化

先明确递推的方向，如图，求解 dp[2][2] 是由 上方和左上方推出。

img

那么二维数组的最上行 和 最左列一定要初始化，这是递推公式推导的基础，如图红色部分：

img

关于dp[0][0]的值，在上面的递推公式讲解中已经讲过，装满背包容量为0 的方法数量是1，即 放0件物品。

那么最上行dp[0][j] 如何初始化呢？

dp[0][j]：只放物品0， 把容量为j的背包填满有几种方法。

只有背包容量为 物品0 的容量的时候，方法为1，正好装满。

其他情况下，要不是装不满，要不是装不下。

所以初始化：dp[0][nums[0]] = 1 ，其他均为0 。

表格最左列也要初始化，dp[i][0] : 背包容量为0， 放物品0 到 物品i，装满有几种方法。

都是有一种方法，就是放0件物品。

即 dp[i][0] = 1

  1. 确定遍历顺序

在明确递推方向时，我们知道 当前值 是由上方和左上方推出。

那么我们的遍历顺序一定是 从上到下，从左到右。

因为只有这样，我们才能基于之前的数值做推导。

例如下图，如果上方没数值，左上方没数值，就无法推出 dp[2][2]。

img

那么是先 从上到下 ，再从左到右遍历，例如这样：

for (int i = 1; i < nums.size(); i++) { // 行，遍历物品
    for (int j = 0; j <= bagSize; j++) { // 列，遍历背包
    }
}

还是先 从左到右，再从上到下呢，例如这样：

for (int j = 0; j <= bagSize; j++) { // 列，遍历背包
    for (int i = 1; i < nums.size(); i++) { // 行，遍历物品
    }
}

其实以上两种遍历都可以！ （但仅针对二维DP数组是这样的）

这一点我在 01背包理论基础 (opens new window)中的 遍历顺序部分讲过。

这里我再画图讲一下，以求dp[2][2]为例，当先从上到下，再从左到右遍历，矩阵是这样：

img

当先从左到右，再从上到下遍历，矩阵是这样：

img

这里大家可以看出，无论是以上哪种遍历，都不影响 dp[2][2]的求值，用来 推导 dp[2][2] 的数值都在。

  1. 举例推导dp数组

输入：nums: [1, 1, 1, 1, 1], target: 3

bagSize = (target + sum) / 2 = (3 + 5) / 2 = 4

dp数组状态变化如下：

img

这么大的矩阵，我们是可以自己手动模拟出来的。

在模拟的过程中，既可以帮我们寻找规律，也可以帮我们验证 递推公式加遍历顺序是不是按照我们想象的结果推进的。

最后二维dp数组的C++代码如下：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) sum += nums[i];
        if (abs(target) > sum) return 0; // 此时没有方案
        if ((target + sum) % 2 == 1) return 0; // 此时没有方案
        int bagSize = (target + sum) / 2;
        
        vector<vector<int>> dp(nums.size(), vector<int>(bagSize + 1, 0));
        
        // 初始化最上行
        if (nums[0] <= bagSize) dp[0][nums[0]] = 1; 

        // 初始化最左列，最左列其他数值在递推公式中就完成了赋值
        dp[0][0] = 1; 

        int numZero = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == 0) numZero++;
            dp[i][0] = (int) pow(2.0, numZero);
        }

        // 以下遍历顺序行列可以颠倒
        for (int i = 1; i < nums.size(); i++) { // 行，遍历物品
            for (int j = 0; j <= bagSize; j++) { // 列，遍历背包
                if (nums[i] > j) dp[i][j] = dp[i - 1][j]; 
                else dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];
            }
        }
        return dp[nums.size() - 1][bagSize];
    }
};

#动态规划 （一维dp数组）

将二维dp数组压缩成一维dp数组，重复利用每一行，就是将二维数组压缩成一行。

dp[i][j] 去掉 行的维度，即 dp[j]，表示：填满j（包括j）这么大容积的包，有dp[j]种方法。

  1. 确定递推公式

二维DP数组递推公式： dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];

去掉维度i 之后，递推公式：dp[j] = dp[j] + dp[j - nums[i]] ，即：dp[j] += dp[j - nums[i]]

这个公式在后面在讲解背包解决排列组合问题的时候还会用到！

  1. dp数组如何初始化

在上面 二维dp数组中，我们讲解过 dp[0][0] 初始为1，这里dp[0] 同样初始为1 ,即装满背包为0的方法有一种，放0件物品。

  1. 确定遍历顺序

在动态规划：关于01背包问题，你该了解这些！（滚动数组） (opens new window)中，我们系统讲过对于01背包问题一维dp的遍历。

遍历物品放在外循环，遍历背包在内循环，且内循环倒序（为了保证物品只使用一次）。

  1. 举例推导dp数组

输入：nums: [1, 1, 1, 1, 1], target: 3

bagSize = (target + sum) / 2 = (3 + 5) / 2 = 4

dp数组状态变化如下：

img

大家可以和 二维dp数组的打印结果做一下对比。

一维DP的C++代码如下：

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) sum += nums[i];
        if (abs(target) > sum) return 0; // 此时没有方案
        if ((target + sum) % 2 == 1) return 0; // 此时没有方案
        int bagSize = (target + sum) / 2;
        vector<int> dp(bagSize + 1, 0);
        dp[0] = 1;
        for (int i = 0; i < nums.size(); i++) {
            for (int j = bagSize; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[bagSize];
    }
};
  • 时间复杂度：O(n × m)，n为正数个数，m为背包容量
  • 空间复杂度：O(m)，m为背包容

题目三： 474.一和零

没太明白，期待二刷

解题思路：

本题中strs 数组里的元素就是物品，每个物品都是一个！

而m 和 n相当于是一个背包，两个维度的背包。

理解成多重背包的同学主要是把m和n混淆为物品了，感觉这是不同数量的物品，所以以为是多重背包。

但本题其实是01背包问题！

只不过这个背包有两个维度，一个是m 一个是n，而不同长度的字符串就是不同大小的待装物品。

开始动规五部曲：

  1. 确定dp数组（dp table）以及下标的含义

dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。

2.确定递推公式

dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。

dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1。

然后我们在遍历的过程中，取dp[i][j]的最大值。

所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

此时大家可以回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

对比一下就会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。

这就是一个典型的01背包！ 只不过物品的重量有了两个维度而已。

  1. dp数组如何初始化

    因为物品价值不会是负数，初始为0，保证递推的时候dp[i][j]不会被初始值覆盖。

  2. 确定遍历顺序

01背包一定是外层for循环遍历物品，内层for循环遍历背包容量且从后向前遍历！

那么本题也是，物品就是strs里的字符串，背包容量就是题目描述中的m和n。

代码如下：

for (string str : strs) { // 遍历物品
    int oneNum = 0, zeroNum = 0;
    for (char c : str) {
        if (c == '0') zeroNum++;
        else oneNum++;
    }
    for (int i = m; i >= zeroNum; i--) { // 遍历背包容量且从后向前遍历！
        for (int j = n; j >= oneNum; j--) {
            dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
        }
    }
}

5.举例推导dp数组

以输入：[“10”,“0001”,“111001”,“1”,“0”]，m = 3，n = 3为例

最后dp数组的状态如下所示：

474.一和零

以上动规五部曲分析完毕，C++代码如下：

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        vector<vector<int>> dp(m + 1, vector<int> (n + 1, 0)); // 默认初始化0
        for (string str : strs) { // 遍历物品
            int oneNum = 0, zeroNum = 0;
            for (char c : str) {
                if (c == '0') zeroNum++;
                else oneNum++;
            }
            for (int i = m; i >= zeroNum; i--) { // 遍历背包容量且从后向前遍历！
                for (int j = n; j >= oneNum; j--) {
                    dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
                }
            }
        }
        return dp[m][n];
    }
};
  • 时间复杂度: O(kmn)，k 为strs的长度
  • 空间复杂度: O(mn)

C++: 使用三维数组的版本

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        int num_of_str = strs.size();

		vector<vector<vector<int>>> dp(num_of_str, vector<vector<int>>(m + 1,vector<int>(n + 1, 0)));

		/* 	dp[i][j][k] represents, if choosing items among strs[0] to strs[i] to form a subset, 
			what is the maximum size of this subset such that there are no more than m 0's and n 1's in this subset. 
			Each entry of dp[i][j][k] is initialized with 0
			
			transition formula:
			using x[i] to indicates the number of 0's in strs[i]
			using y[i] to indicates the number of 1's in strs[i]
			
			dp[i][j][k] = max(dp[i-1][j][k], dp[i-1][j - x[i]][k - y[i]] + 1)

		*/


		// num_of_zeros records the number of 0's for each str
		// num_of_ones records the number of 1's for each str
		// find the number of 0's and the number of 1's for each str in strs
		vector<int> num_of_zeros;
		vector<int> num_of_ones;
		for (auto& str : strs){
			int count_of_zero = 0;
			int count_of_one = 0;
			for (char &c : str){
				if(c == '0') count_of_zero ++;
				else count_of_one ++;
			}
			num_of_zeros.push_back(count_of_zero);
			num_of_ones.push_back(count_of_one);
			
		}

		
		// num_of_zeros[0] indicates the number of 0's for str[0]
		// num_of_ones[0] indiates the number of 1's for str[1]

		// initialize the 1st plane of dp[i][j][k], i.e., dp[0][j][k]
		// if num_of_zeros[0] > m or num_of_ones[0] > n, no need to further initialize dp[0][j][k], 
		// because they have been intialized to 0 previously
		if(num_of_zeros[0] <= m && num_of_ones[0] <= n){
			// for j < num_of_zeros[0] or k < num_of_ones[0], dp[0][j][k] = 0
			for(int j = num_of_zeros[0]; j <= m; j++){
				for(int k = num_of_ones[0]; k <= n; k++){
					dp[0][j][k] = 1;
				}
			}
		}

		/*	if j - num_of_zeros[i] >= 0 and k - num_of_ones[i] >= 0:
				dp[i][j][k] = max(dp[i-1][j][k], dp[i-1][j - num_of_zeros[i]][k - num_of_ones[i]] + 1)  
			else:
				dp[i][j][k] = dp[i-1][j][k]
		*/

		for (int i = 1; i < num_of_str; i++){
			int count_of_zeros = num_of_zeros[i];
			int count_of_ones = num_of_ones[i]; 
			for (int j = 0; j <= m; j++){
				for (int k = 0; k <= n; k++){
					if( j < count_of_zeros || k < count_of_ones){
						dp[i][j][k] = dp[i-1][j][k];
					}else{
						dp[i][j][k] = max(dp[i-1][j][k], dp[i-1][j - count_of_zeros][k - count_of_ones] + 1);
					}
				}
			}
			
		}

		return dp[num_of_str-1][m][n];

    }
};

总结

  • 今天学习的内容，学的很泛，没太明白
  • 坚持进度吧
LluckyYH
关注
《代码随想录》LeetCode 刷题攻略：200道经典题目刷题顺序，共60w字的详细图解，视频难点剖析，50余张思维.zip
02-21
《代码随想录》是一本专注于LeetCode刷题攻略的资源集合，旨在帮助程序员提升算法能力和编程技巧。这本书包含了200道精心挑选的经典题目，覆盖了数据结构、算法、设计模式等多个方面，总计约60万字的详细解析，配以...
php-leetcode题解之最后一块石头的重量.zip
06-14
在本压缩包“php-leetcode题解之最后一块石头的重量.zip”中，包含的是针对LeetCode算法问题“最后一块石头的重量”的解决方案，主要针对使用PHP编程语言进行解答。LeetCode是一个广受欢迎的在线平台，它提供了各种...
代码随想录算法训练营第 36 天 |LeetCode1049. 最后一块石头的重量 II LeetCode 494. 目标和 LeetCode 474.一和零
2301_79647020的博客
08-23 323
01背包
【算法刷题day43】Leetcode：1049. 最后一块石头的重量 II、494. 目标和、474. 一和零
qq_45022758的博客
05-08 535
题目：1049. 最后一块石头的重量 II解析：代码随想录解析暂无暂无暂无1049. 最后一块石头的重量 II代码随想录解析494. 目标和代码随想录解析474. 一和零代码随想录解析。
代码随想录第四十三天|Leetcode1049. 最后一块石头的重量 II、Leetcode494. 目标和、Leetcode474.一和零
muzi_taibai的博客
03-15 222
Leetcode1049. 最后一块石头的重量 II这题好难。
代码随想录Day36 动态规划05 LeetCode T1049最后一块石头的重量II T494 目标和 T474 一和零
qiuqiushuibx的博客
11-03 1739
动态规划05
代码随想录算法训练营Day42 | 1049. 最后一块石头的重量 II 494. 目标和 474.一和零
qq_24817679的博客
05-18 400
题目链接：LeetCode 1049. 最后一块石头的重量 II思路： sum - 2*dp[target]; 注意 ：题目链接：LeetCode 494. 目标和 思路： 组合问题，就是将所有没放nums[i]的情况 加上现有情况，遍历。 注意 ：题目链接：LeetCode 474.一和零 思路： 注意 ： 1. 2. 3. 4.题目链接：LeetCode 704 二分查找思路：二维01背包 注意 ：
代码随想录第三十六天|1049. 最后一块石头的重量 II、494. 目标和、474.一和零
2301_78639103的博客
08-23 153
递推公式：dp[j] += dp[j - nums[i]]1049. 最后一块石头的重量 II。
LeetCode Day43 | 1049. 最后一块石头的重量 II、494. 目标和、474. 一和零
m0_37830008的博客
04-12 106
LeetCode 1049. 最后一块石头的重量 II、494. 目标和、474. 一和零
代码随想录训练营Day43| 1049. 最后一块石头的重量 II 494. 目标和 474.一和零
weixin_44174445的博客
05-17 395
1049. 最后一块石头的重量 II - 力扣（LeetCode）494. 目标和 - 力扣（LeetCode）474. 一和零 - 力扣（LeetCode）1049. 最后一块石头的重量 II。1049. 最后一块石头的重量 II。
代码随想录Day43 | 1049. 最后一块石头的重量 II 494. 目标和
sRiddle的博客
02-08 950
Day43
代码随想录算法训练营第43天 | 1049. 最后一块石头的重量 II 494. 目标和 474.一和零
miracle_world的博客
12-25 852
动态规划
leetcode和oj-leetcode:oj.leetcode.com中的问题及解决方案
06-30
LeetCode是一个广受欢迎的在线编程挑战平台，它提供了丰富的算法和数据结构题目，涵盖了从基础到高级的各种难度。用户可以通过解决这些问题来提升自己的编程能力和算法理解。LeetCode的特色在于它支持多种编程语言，...
Leetcode 打家劫舍
985小菜鸡
10-08 427
设dp[i]表示前i个房屋能偷取的最大金额。不偷当前房屋 i：那么最大金额是dp[i-1]，即上一个房屋的最大偷取金额。偷当前房屋 i：那么最大金额是，即偷取当前房屋 i，加上不相邻的房屋（即房屋i-2）的最大金额。其中dp[i-1]是不偷当前房屋，是偷当前房屋。
Golang | Leetcode Golang题解之第461题汉明距离
weixin_66442839的博客
10-07 484
Golang | Leetcode Golang题解之第461题汉明距离
LeetCode | 704.二分查找
最新发布
编程菜鸟的学习记录
10-12 118
LeetCode | 704.二分查找
力扣11-盛最多水的容器
qq_40926675的博客
10-09 625
给定一个长度为n的整数数组height。有n条垂线，第i条线的两个端点是(i, 0)和。找出其中的两条线，使得它们与x轴共同构成的容器可以容纳最多的水。返回容器可以储存的最大水量。你不能倾斜容器。
LeetCode组合总和
山雀的博客
10-09 827
LeetCode组合总和
leetcode:1.two sum两数之和 给定一个整数数组和一个目标值,找出数组中和
08-10
给定一个整数数组 nums 和一个目标值 target，要求在数组中找出两个数的和等于目标值，并返回这两个数的索引。 思路1：暴力法 最简单的思路是使用两层循环遍历数组的所有组合，判断两个数的和是否等于目标值。如果等于目标值，则返回这两个数的索引。 此方法的时间复杂度为O(n^2)，空间复杂度为O(1)。 思路2：哈希表 为了优化时间复杂度，可以使用哈希表来存储数组中的元素和对应的索引。遍历数组，对于每个元素nums[i]，我们可以通过计算target - nums[i]的值，查找哈希表中是否存在这个差值。 如果存在，则说明找到了两个数的和等于目标值，返回它们的索引。如果不存在，将当前元素nums[i]和它的索引存入哈希表中。 此方法的时间复杂度为O(n)，空间复杂度为O(n)。 思路3：双指针 如果数组已经排序，可以使用双指针的方法来求解。假设数组从小到大排序，定义左指针left指向数组的第一个元素，右指针right指向数组的最后一个元素。 如果当前两个指针指向的数的和等于目标值，则返回它们的索引。如果和小于目标值，则将左指针右移一位，使得和增大；如果和大于目标值，则将右指针左移一位，使得和减小。 继续移动指针，直到找到两个数的和等于目标值或者左指针超过了右指针。 此方法的时间复杂度为O(nlogn)，空间复杂度为O(1)。 以上三种方法都可以解决问题，选择合适的方法取决于具体的应用场景和要求。如果数组规模较小并且不需要考虑额外的空间使用，则暴力法是最简单的方法。如果数组较大或者需要优化时间复杂度，则哈希表或双指针方法更合适。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值