代码随想录 | Day38 | 动态规划 ：01背包应用 目标和一和零

代码随想录 | Day38 | 动态规划 ：01背包应用 目标和&&一和零

动态规划应该如何学习？-CSDN博客

01背包模板 | 学习总结-CSDN博客

难点：

代码都不难写，如何想到01背包并把具体问题抽象为01背包才是关键

这真的不能怪笔者拖更，这两道题真给我整麻了

文章目录

  • 代码随想录 | Day38 | 动态规划 ：01背包应用 目标和&&一和零
    • 494.目标和（恰好等于背包容量求方案数）
      • 思路分析：
      • 1.回溯法
      • 2.01背包
        • 1.回溯暴力枚举
        • 2.记忆化搜索
        • 3.1:1翻译为动态规划
        • 4.滚动数组优化
    • 474.一和零
      • 思路分析：
      • 1.回溯暴力枚举
      • 2.记忆化搜索
      • 3. 1:1翻译为动态规划
      • 4.滚动数组优化

494.目标和（恰好等于背包容量求方案数）

[494. 目标和 - 力扣（LeetCode）](https://leetcode.cn/problems/partition-equal-subset-sum/description/)

思路分析：

设前面要加“+”的数和为p，前面要加“-”的数的和为q。

p+q=sum（数组所有元素的和）

p-q=target（要加正号的减去要加负号的）

2p=sum+target

p=(sum+target)/2

也就是说呢，我们要在nums数组里面找一个子集，让子集的和等于p，能找到几个就有几种方案

1.回溯法

本题也可以使用回溯暴力枚举，直接搜索nums里面的所有组合，等于target的就是答案。

这是组合总和的代码，当然是超时的

class Solution {
private:vector<vector<int>> result;vector<int> path;void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {if (sum == target) {result.push_back(path);}// 如果 sum + candidates[i] > target 就终止遍历for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {sum += candidates[i];path.push_back(candidates[i]);backtracking(candidates, target, sum, i + 1);sum -= candidates[i];path.pop_back();}}
public:int findTargetSumWays(vector<int>& nums, int S) {int sum = 0;for (int i = 0; i < nums.size(); i++) sum += nums[i];if (S > sum) return 0; // 此时没有方案if ((S + sum) % 2) return 0; // 此时没有方案，两个int相加的时候要格外小心数值溢出的问题int bagSize = (S + sum) / 2; // 转变为组合总和问题，bagsize就是要求的和// 以下为回溯法代码result.clear();path.clear();sort(nums.begin(), nums.end()); // 需要排序backtracking(nums, bagSize, 0, 0);return result.size();}
};

2.01背包

如何转换为01背包呢？

1.因为是子集，所以每个数只有选或者不选两个选项，不会有重复

2.就是把nums里面的数字当做物品，他们的价值和重量全是他们本身的数值

3.而我们背包的容量c就是target这个值，只要我们的方案可以刚好把背包给填满了，那说明背包里面放进去的nums[i]加和就是target

如果不是刚好填满，那肯定找不出子集加起来正好是target

转变为01背包后的递推公式变化？

dp/dfs表示从前 i 个数中从选一些数恰好组成 j 的方案数

就是从前i个数里面随便选，能正号填满容量j的方案数

只需要把01背包的max换成+即可

dp[i][j]=dp[i-1][j]+dp[i-1][j-w[i]];

dp[i][j]是由两个情况相加得到的。我们没有选第i件物品和选了第i件物品

选了那方案数就得加上在容量为j-w[i]的情况下的方案数

没选那方案数就得加上选上一个物品的时候在容量为j的情况下的方案数（上一个物品也分为选或不选）

这里是加法原理，选和不选第i个物品的情况是互斥的，我们要得到所有的方案数量就需要把它加起来

1.回溯暴力枚举

1.参数和返回值

i是物品编号

c是当前容量

nums是题数组

dfs(i,c) 表示从前 i 个数中从选一些数恰好组成 c 的方案数

int dfs(int i,int c,vector<int>& nums)

2.终止条件

1.i<0说明没有物品可以选了，如果当前容量正好等于0，那就返回1说明找到了一个合法方案

不等于0就返回0说明没找到

2.如果当前容量已经小于了物品所需的容量，那说明背包装不下，那就只能不选这个物品了，就返回不选这个物品的方案数量，即在前i-1个物品里面能凑够容量c的方案数

		if(i<0)if(c==0)return 1;elsereturn 0;if(c<nums[i])return dfs(i-1,c,nums);

3.本层逻辑

返回 在前i个物品中，选了第i个物品能满足c的方案数和没选第i个物品能满足c的方案数之和

return dfs(i-1,c-nums[i],nums)+dfs(i-1,c,nums);

完整代码

class Solution {
public:int dfs(int i,int c,vector<int>& nums){if(i<0)if(c==0)return 1;elsereturn 0;if(c<nums[i])return dfs(i-1,c,nums);return dfs(i-1,c-nums[i],nums)+dfs(i-1,c,nums);}int findTargetSumWays(vector<int>& nums, int target) {int sum=0;for(int c:nums)sum+=c;int p=sum+target;if (p < 0 || p % 2 != 0)return 0;target=p/2;return dfs(nums.size()-1,target,nums);}
};
2.记忆化搜索

还是老样子

初始化dp为-1，如果不是-1说明计算过了直接返回

并且在返回之前给dp赋值

class Solution {
public:int dfs(int i,int c,vector<int>& nums,vector<vector<int>>& dp){if(i<0)if(c==0)return 1;elsereturn 0;if(c<nums[i])return dp[i][c]=dfs(i-1,c,nums,dp);if(dp[i][c]!=-1)return dp[i][c];return dp[i][c]=dfs(i-1,c-nums[i],nums,dp)+dfs(i-1,c,nums,dp);}int findTargetSumWays(vector<int>& nums, int target) {int sum=0;for(int c:nums)sum+=c;int p=sum+target;if (p < 0 || p % 2 != 0)return 0;target=p/2;vector<vector<int>> dp(nums.size(),vector<int>(target+1,-1));return dfs(nums.size()-1,target,nums,dp);}
};

//lambda
class Solution {
public:int findTargetSumWays(vector<int>& nums, int target) {int sum=0;for(int c:nums)sum+=c;int p=sum+target;if (p < 0 || p % 2 != 0)return 0;target=p/2;vector<vector<int>> dp(nums.size(),vector<int>(target+1,-1));function<int(int,int)> dfs=[&](int i,int c)->int{if(i<0)if(c==0)return 1;elsereturn 0;if(c<nums[i])return dp[i][c]=dfs(i-1,c);if(dp[i][c]!=-1)return dp[i][c];return dp[i][c]=dfs(i-1,c-nums[i])+dfs(i-1,c);};return dfs(nums.size()-1,target);}
};
3.1:1翻译为动态规划

注意这里把dp数组里面的下标i都加了1（重点）

因为这样做可以避免负数下标的出现

一种好理解的方式是dp[i][j]含义是在前i个物品里面选，容量刚好满足j

物品编号是1-i，而不是0-i

那为什么nums数组的下标没有加+1呢？

因为nums数组从0开始的，dp数组中的i，表示第i件物品，而第i件物品的重量和价值和nums[i-1]

dp[i+1][j]=dp[i][j]+dp[i+1][j-nums[i]];

关于初始化就看上面回溯的终止条件

i<0&&c==0就为1，那里的i是我们这里的i-1，因为我们给dp数组的i下标都加了1

也就是说

dp[i][0]全都为1

但这里只需要把dp[0][0]=1就行，其他的会在循环中给他赋值的，最后打印出来也确实是1

完整代码：

class Solution {
public:int findTargetSumWays(vector<int>& nums, int target) {int sum=0;for(int c:nums)sum+=c;int p=sum+target;if (p < 0 || p % 2 != 0)return 0;target=p/2;vector<vector<int>> dp(nums.size()+1,vector<int>(target+1,0));dp[0][0]=1;for(int i=0;i<nums.size();i++)for(int j=0;j<=target;j++)if(j<nums[i])dp[i+1][j]=dp[i][j];elsedp[i+1][j]=dp[i][j]+dp[i][j-nums[i]];return dp[nums.size()][target];}
};
4.滚动数组优化
class Solution {
public:int findTargetSumWays(vector<int>& nums, int target) {int sum=0;for(int c:nums)sum+=c;int p=sum+target;if (p < 0 || p % 2 != 0)return 0;target=p/2;vector<int> dp(target+1,0);dp[0]=1;for(int i=0;i<nums.size();i++)for(int j=target;j>=nums[i];j--)dp[j]=dp[j]+dp[j-nums[i]];return dp[target];}
};

474.一和零

474. 一和零 - 力扣（LeetCode）

思路分析：

这道题我也没想到怎么联系到01背包，或者说怎么应用

看了题解以后才了解到了

咱们平时的容量限制是物品i的重量

今天的容量限制是物品i（字符串strs[i]）里面的0和1的数量，就是说有两个限制，一个是0的数量，一个是1的数量，说明这是一个三维数组，而每个物品i（字符串strs[i]）的价值是多少？

因为求的是子集的数量，所以每一个字符串的价值都为1，就是放这个字符串i进去，就加1，不放就不加

举例：

比如说我们放的放的，背包容量只能装2个0和三个1了

那我们下一个strs[i]如果是 000111，有3个0，3个1那也放不进去

001111也不行

0000也不行

就是两个要都满足

比如0011，然后放进去以后最大的方案数+1

所以本质上就是01背包的容量多加了一个维度

递推公式直接仿照着写

dp[i][j] = max(dp[i-1][j], dp[i-1][j - w[i]] + v[i]);

dp[i][j][k] = max(dp[i-1][j][k], dp[i-1][j - zeronum][k - onenum] + 1);

当前的最大数量那就是不放当前字符串和放了当前字符串这两种情况里面选一个最大值，如果我我们选了当前字符串那就+1，因为dp含义是在前i个字符串里面选的最多有j个0和k个1的子集中的字符串数量。

1.回溯暴力枚举

1.参数和返回值

i是物品编号，标识到了第几个字符串了

j是当前0的容量，k是当前1的容量

strs是题数组

dfs(i,j,k,strs) 含义是在前i个字符串里面选的最多有j个0和k个1的子集中的字符串数量

int dfs(int i,int j,int k,vector<string>& strs)

2.终止条件

1.i<0说明没有物品可以选了，如果当前容量正好等于0，那就返回1说明找到了一个合法方案

不等于0就返回0说明没找到

2.如果当前容量已经小于了物品所需的容量，那说明背包装不下，那就只能不选这个物品了，就返回不选这个物品的方案数量，即在前i-1个物品里面能凑够容量c的方案数

if(i<0)return 0;
if(j<zeronum || k<onenum)//0和1只要有一个不够就不放 return dfs(i-1,j,k,strs);

3.本层逻辑

返回当前的最大数量，就是不放当前字符串和放了当前字符串这两种情况里面选一个最大值

		int zeronum=0;int onenum=0;for(auto c:strs[i])if(c=='0')zeronum++;elseonenum++;if(j<zeronum || k<onenum)return dfs(i-1,j,k,strs);return max(dfs(i-1,j,k,strs),dfs(i-1,j-zeronum,k-onenum,strs)+1);

完整代码

当然是超时的

class Solution {
public:int dfs(int i,int c,vector<int>& nums){if(i<0)if(c==0)return 1;elsereturn 0;if(c<nums[i])return dfs(i-1,c,nums);return dfs(i-1,c-nums[i],nums)+dfs(i-1,c,nums);}int findTargetSumWays(vector<int>& nums, int target) {int sum=0;for(int c:nums)sum+=c;int p=sum+target;if (p < 0 || p % 2 != 0)return 0;target=p/2;return dfs(nums.size()-1,target,nums);}
};

2.记忆化搜索

还是老样子

初始化dp为-1，如果不是-1说明计算过了直接返回

并且在返回之前给dp赋值

class Solution {
public:int dfs(int i,int j,int k,vector<string>& strs,vector<vector<vector<int>>>& dp){if(i<0)return 0;int zeronum=0;int onenum=0;for(auto c:strs[i])if(c=='0')zeronum++;elseonenum++;if(dp[i][j][k]!=-1)return dp[i][j][k];if(j<zeronum || k<onenum)return dp[i][j][k]=dfs(i-1,j,k,strs,dp);return dp[i][j][k]=max(dfs(i-1,j,k,strs,dp),dfs(i-1,j-zeronum,k-onenum,strs,dp)+1);}int findMaxForm(vector<string>& strs, int m, int n) {vector<vector<vector<int>>> dp(strs.size(),vector<vector<int>>(m+1,vector<int>(n+1,-1)));return dfs(strs.size()-1,m,n,strs,dp);}
};

//lambda
虚晃一枪，笔者懒得写了，大家自己写吧

3. 1:1翻译为动态规划

多加了初始化部分，就是物品1，能放下的地方初始化为1，放不下的初始化为0

		int zeronum=0;int onenum=0;for(auto c:strs[0])if(c=='0')zeronum++;elseonenum++;for(int j=0;j<=m;j++)for(int k=0;k<=n;k++)if(j<zeronum||k<onenum)dp[0][j][k]=0;elsedp[0][j][k]=1;

完整代码：

class Solution {
public:int findMaxForm(vector<string>& strs, int m, int n) {vector<vector<vector<int>>> dp(strs.size(),vector<vector<int>>(m+1,vector<int>(n+1,0)));int zeronum=0;int onenum=0;for(auto c:strs[0])if(c=='0')zeronum++;elseonenum++;for(int j=0;j<=m;j++)for(int k=0;k<=n;k++)if(j<zeronum||k<onenum)dp[0][j][k]=0;elsedp[0][j][k]=1;for(int i=1;i<strs.size();i++){zeronum=0;onenum=0;for(auto c:strs[i])if(c=='0')zeronum++;elseonenum++;for(int j=0;j<=m;j++)for(int k=0;k<=n;k++)if(j<zeronum||k<onenum)dp[i][j][k]=dp[i-1][j][k];elsedp[i][j][k]=max(dp[i-1][j][k],dp[i-1][j-zeronum][k-onenum]+1);}return dp[strs.size()-1][m][n];}
};

4.滚动数组优化

和01背包一样，先遍历物品

容量倒着遍历

删掉物品编号那一维

除了初始化为0不需要其他的初始化动作

class Solution {
public:int findMaxForm(vector<string>& strs, int m, int n) {vector<vector<int>> dp(m+1,vector<int>(n+1,0));for(int i=0;i<strs.size();i++){int zeronum=0;int onenum=0;for(auto c:strs[i])if(c=='0')zeronum++;elseonenum++;for(int j=m;j>=zeronum;j--)for(int k=n;k>=onenum;k--)dp[j][k]=max(dp[j][k],dp[j-zeronum][k-onenum]+1);}return dp[m][n];}
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/web/58611.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

八，附录 A：其他发现流程示例

八，附录 A：其他发现流程示例

八&#xff0c;附录 A&#xff1a;其他发现流程示例 八&#xff0c;附录 A&#xff1a;其他发现流程示例8.1 修改后的发现流程8.2 优化后的发现流程8.3 高级发现流程 八&#xff0c;附录 A&#xff1a;其他发现流程示例 以下部分提供了关于修改后的、优化后的和高级的发现流程…
阅读更多...
实战：看懂并分析执行计划——Clustered Index Scan

实战：看懂并分析执行计划——Clustered Index Scan

这是 Clustered Index Scan 的执行计划详情，以下是对每一行的含义及其对查询性能的可能影响的解释。 Clustered Index Scan (Clustered) 解释 Physical Operation: Clustered Index Scan (Clustered) 物理操作，表明数据库引擎在整个聚集索引上进行扫描。Clustered Index Sc…
阅读更多...
linux-find和zgrep

linux-find和zgrep

zgrep 命令本身并不支持递归搜索&#xff0c;它只能搜索单个压缩文件。但是&#xff0c;你可以结合使用 find 命令和 xargs 来实现递归搜索。下面是一个使用 find 和 xargs 来递归搜索所有 .gz 压缩文件中包含特定文本的例子&#xff1a; find /path/to/directory -type f -na…
阅读更多...
C#核心(8) 静态成员

C#核心(8) 静态成员

前言 先前我们已经学习了成员变量以及成员属性。 静态成员对于在整个应用程序中共享数据和功能非常有用。它们可以用于跟踪全局状态、共享常量和实现单例模式等。但是需要注意的是&#xff0c;过度使用静态成员可能导致代码变得难以维护和测试&#xff0c;因此应谨慎使用。其…
阅读更多...
Jenkins声明式Pipeline流水线语法示例

Jenkins声明式Pipeline流水线语法示例

系列文章目录 docker搭建Jenkins2.346.3版本及常用工具集成配置(ldap、maven、ansible、npm等) docker安装低版本的jenkins-2.346.3,在线安装对应版本插件失败的解决方法 文章目录 系列文章目录jenkins流水线基础1、pipeline1.1、什么是pipeline&#xff1f;1.2、为什么使用pi…
阅读更多...
OceanBase中，如何解读 obdiag 收集的火焰图 【DBA早下班系列】

OceanBase中，如何解读 obdiag 收集的火焰图 【DBA早下班系列】

1. 前言 在之前的文章 遇到性能问题&#xff0c;如何给OceanBase“拍CT“&#xff08;火焰图与扁鹊图&#xff09;中&#xff0c;分享了obdiag 快速收集火焰图的方法&#xff0c;那么&#xff0c;紧接着的问题便是&#xff1a;收集到火焰图和扁鹊图之后&#xff0c;该如何解读…
阅读更多...
网站架构知识之Ansible模块（day021）

网站架构知识之Ansible模块（day021）

1.Ansible模块 作用:通过ansible模块实现批量管理 2.command模块与shell模块 command模块是ansible默认的模块&#xff0c;适用于执行简单的命令&#xff0c;不支持特殊符号 案列01&#xff0c;批量获取主机名 ansible all -m command -a hostname all表示对主机清单所有组…
阅读更多...
Browserslist 配置

Browserslist 配置

Browserslist 是一个工具和规范&#xff0c;用于定义和共享支持的浏览器列表&#xff0c;以便在前端开发中管理不同工具的兼容性。这些工具可以包括 Babel、Autoprefixer、ESLint 等&#xff0c;它们都可以使用 Browserslist 提供的配置来确定应支持哪些浏览器及其版本。 主要…
阅读更多...
短期电力负荷

短期电力负荷

&#x1f3e1;作者主页&#xff1a;点击&#xff01; &#x1f916;编程探索专栏&#xff1a;点击&#xff01; ⏰️创作时间&#xff1a;2024年11月8日9点40分 论文发表 来自《IEEE Transactions on Smart Grid》2022年7月的13卷第4期&#xff0c;《IEEE Transactions on …
阅读更多...
十四：java web（6）-- Spring Spring MVC

十四：java web（6）-- Spring Spring MVC

目录 Spring MVC 1.1 Spring MVC 概述 1.1.1 什么是 MVC 模式 1.1.2 Spring MVC 工作原理 1.2 Spring MVC 核心组件 1.2.1 DispatcherServlet 1.2.2 控制器&#xff08;Controller&#xff09; 1.2.3 请求映射&#xff08;RequestMapping&#xff09; 1.2.4 视图解析器…
阅读更多...
redis与本地缓存

redis与本地缓存

本地缓存是将数据存储在应用程序所在的本地内存中的缓存方式。既然&#xff0c;已经有了 Redis 可以实现分布式缓存了&#xff0c;为什么还需要本地缓存呢&#xff1f;接下来&#xff0c;我们一起来看。 为什么需要本地缓存&#xff1f; 尽管已经有 Redis 缓存了&#xff0c;但…
阅读更多...
linux tigerVNC使用

linux tigerVNC使用

简介 TigerVNC是VNC的一种高性能、平台中立实现&#xff08;虚拟网络计算&#xff09;&#xff0c;一种客户端/服务器应用程序&#xff0c;允许用户启动远程图形应用程序并与之交互机器。TigerVNC提供运行所需的性能级别3D和视频应用程序&#xff0c;并尝试保持普通外观并尽可…
阅读更多...
基于redis实现API接口访问次数限制

基于redis实现API接口访问次数限制

一&#xff0c;概述 日常开发中会有一个常见的需求&#xff0c;需要限制接口在单位时间内的访问次数&#xff0c;比如说某个免费的接口限制单个IP一分钟内只能访问5次。该怎么实现呢&#xff0c;通常大家都会想到用redis&#xff0c;确实通过redis可以实现这个功能&#xff0c…
阅读更多...
uni-app小程序开发（1）

uni-app小程序开发（1）

下载软件就不多赘述了。 直接上代码&#xff0c;写过wep端的vue看这个小程序就简单很多&#xff0c;不需要搞那么多麻烦事情&#xff0c;直接编译器就创建好了基础模版。 1、项目结构 暂时知道这么多&#xff0c;后续再补充 2、页面创建、导航栏设置、基础属性设置 在pages中…
阅读更多...
【C++】哈希表封装 unordered_map 和 unordered_set 的实现过程

【C++】哈希表封装 unordered_map 和 unordered_set 的实现过程

C语法相关知识点可以通过点击以下链接进行学习一起加油&#xff01;命名空间缺省参数与函数重载C相关特性类和对象-上篇类和对象-中篇类和对象-下篇日期类C/C内存管理模板初阶String使用String模拟实现Vector使用及其模拟实现List使用及其模拟实现容器适配器Stack与QueuePriori…
阅读更多...
优化策略：揭秘钢条切割与饼干分发的算法艺术

优化策略：揭秘钢条切割与饼干分发的算法艺术

引言 在生活中&#xff0c;钢条和饼干看似风马牛不相及&#xff0c;但它们的分割与分发却隐藏着惊人的数学魅力。如何最大化利润&#xff1f;如何用有限的资源最大程度满足需求&#xff1f;这便是算法世界中的艺术。今天&#xff0c;我们来揭秘钢条切割与饼干分发的算法设计。本…
阅读更多...
SQL，力扣题目1709，访问日期之间最大的空档期

SQL，力扣题目1709，访问日期之间最大的空档期

一、力扣链接 LeetCode_1709 二、题目描述 表&#xff1a; UserVisits ------------------- | Column Name | Type | ------------------- | user_id | int | | visit_date | date | ------------------- 该表没有主键&#xff0c;它可能有重复的行 该表包含用户访问…
阅读更多...
第七篇: BigQuery中的复杂SQL查询

第七篇: BigQuery中的复杂SQL查询

BigQuery中的复杂SQL查询 背景与目标 在数据分析中&#xff0c;我们通常需要从多个数据源中获取信息&#xff0c;以便进行深入的分析。这时&#xff0c;BigQuery提供的JOIN、UNION和子查询等复杂SQL语句非常实用。本文将以Google BigQuery的公共数据集为例&#xff0c;介绍如何…
阅读更多...
【C++】条件变量condition_variable

【C++】条件变量condition_variable

文章目录 1. 条件变量定义及特点2. 代码示例3. wait方法4. wait_for方法5. notify_all和notify_one6. 思考 1. 条件变量定义及特点 条件变量 用于在线程之间协调共享资源的访问。它允许一个线程等待特定条件的满足(如某个值的变化)&#xff0c;而另一个线程在条件满足时通知(或…
阅读更多...
C++ 线程初始化编译报错

C++ 线程初始化编译报错

这是一个很简单的开启一个线程, 用于演示一个线程和生命周期之间的错误,但是还没有把这个错误暴露出来, 就遇见了一个编译问题. 线程中执行指定逻辑的代码 线程的执行方法, 声明写在了ThreadRun.h 实现写在 ThreadRun.cpp中. class ThreadRun { public: void func(); };void T…
阅读更多...
最新文章

Copyright @ 2022~2023