算法与数据结构面试宝典——完全背包问题

于 2023-09-16 21:09:51 发布
阅读量121 收藏 3
点赞数 4
分类专栏： 算法与数据结构面试宝典 文章标签： 算法 数据结构 面试 完全背包
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zy_dreamer/article/details/132924920
版权

完全背包问题

在本节中，我们先求解另一个常见的背包问题：完全背包，再了解它的一种特例：零钱兑换。

完全背包

!!! question

给定 $n$ 个物品，第 $i$ 个物品的重量为 $wgt[i-1]$、价值为 $val[i-1]$ ，和一个容量为 $cap$ 的背包。**每个物品可以重复选取**，问在不超过背包容量下能放入物品的最大价值。

在这里插入图片描述

动态规划思路

完全背包和 0-1 背包问题非常相似，区别仅在于不限制物品的选择次数。

  • 在 0-1 背包中，每个物品只有一个，因此将物品 i i i 放入背包后，只能从前 i − 1 i-1 i−1 个物品中选择。
  • 在完全背包中，每个物品有无数个，因此将物品 i i i 放入背包后，仍可以从前 i i i 个物品中选择。

在完全背包的规定下，状态 [ i , c ] [i, c] [i,c] 的变化分为两种情况。

  • 不放入物品 i i i ：与 0-1 背包相同，转移至 [ i − 1 , c ] [i-1, c] [i−1,c] 。
  • 放入物品 i i i ：与 0-1 背包不同，转移至 [ i , c − w g t [ i − 1 ] ] [i, c-wgt[i-1]] [i,c−wgt[i−1]] 。

从而状态转移方程变为：

d p [ i , c ] = max ⁡ ( d p [ i − 1 , c ] , d p [ i , c − w g t [ i − 1 ] ] + v a l [ i − 1 ] ) dp[i, c] = \max(dp[i-1, c], dp[i, c - wgt[i-1]] + val[i-1]) dp[i,c]=max(dp[i−1,c],dp[i,c−wgt[i−1]]+val[i−1])

代码实现

对比两道题目的代码，状态转移中有一处从 i − 1 i-1 i−1 变为 i i i ，其余完全一致。

=== “Python”

```python title="unbounded_knapsack.py"
[class]{}-[func]{unbounded_knapsack_dp}
```

=== “C++”

```cpp title="unbounded_knapsack.cpp"
[class]{}-[func]{unboundedKnapsackDP}
```

=== “Java”

```java title="unbounded_knapsack.java"
[class]{unbounded_knapsack}-[func]{unboundedKnapsackDP}
```

=== “C#”

```csharp title="unbounded_knapsack.cs"
[class]{unbounded_knapsack}-[func]{unboundedKnapsackDP}
```

=== “Go”

```go title="unbounded_knapsack.go"
[class]{}-[func]{unboundedKnapsackDP}
```

=== “Swift”

```swift title="unbounded_knapsack.swift"
[class]{}-[func]{unboundedKnapsackDP}
```

=== “JS”

```javascript title="unbounded_knapsack.js"
[class]{}-[func]{unboundedKnapsackDP}
```

=== “TS”

```typescript title="unbounded_knapsack.ts"
[class]{}-[func]{unboundedKnapsackDP}
```

=== “Dart”

```dart title="unbounded_knapsack.dart"
[class]{}-[func]{unboundedKnapsackDP}
```

=== “Rust”

```rust title="unbounded_knapsack.rs"
[class]{}-[func]{unbounded_knapsack_dp}
```

=== “C”

```c title="unbounded_knapsack.c"
[class]{}-[func]{unboundedKnapsackDP}
```

=== “Zig”

```zig title="unbounded_knapsack.zig"
[class]{}-[func]{unboundedKnapsackDP}
```

空间优化

由于当前状态是从左边和上边的状态转移而来，因此空间优化后应该对 d p dp dp 表中的每一行采取正序遍历。

这个遍历顺序与 0-1 背包正好相反。请借助下图来理解两者的区别。

=== “<1>”
在这里插入图片描述

=== “<2>”
在这里插入图片描述

=== “<3>”
在这里插入图片描述

=== “<4>”
在这里插入图片描述

=== “<5>”
在这里插入图片描述

=== “<6>”
在这里插入图片描述

代码实现比较简单，仅需将数组 dp 的第一维删除。

=== “Python”

```python title="unbounded_knapsack.py"
[class]{}-[func]{unbounded_knapsack_dp_comp}
```

=== “C++”

```cpp title="unbounded_knapsack.cpp"
[class]{}-[func]{unboundedKnapsackDPComp}
```

=== “Java”

```java title="unbounded_knapsack.java"
[class]{unbounded_knapsack}-[func]{unboundedKnapsackDPComp}
```

=== “C#”

```csharp title="unbounded_knapsack.cs"
[class]{unbounded_knapsack}-[func]{unboundedKnapsackDPComp}
```

=== “Go”

```go title="unbounded_knapsack.go"
[class]{}-[func]{unboundedKnapsackDPComp}
```

=== “Swift”

```swift title="unbounded_knapsack.swift"
[class]{}-[func]{unboundedKnapsackDPComp}
```

=== “JS”

```javascript title="unbounded_knapsack.js"
[class]{}-[func]{unboundedKnapsackDPComp}
```

=== “TS”

```typescript title="unbounded_knapsack.ts"
[class]{}-[func]{unboundedKnapsackDPComp}
```

=== “Dart”

```dart title="unbounded_knapsack.dart"
[class]{}-[func]{unboundedKnapsackDPComp}
```

=== “Rust”

```rust title="unbounded_knapsack.rs"
[class]{}-[func]{unbounded_knapsack_dp_comp}
```

=== “C”

```c title="unbounded_knapsack.c"
[class]{}-[func]{unboundedKnapsackDPComp}
```

=== “Zig”

```zig title="unbounded_knapsack.zig"
[class]{}-[func]{unboundedKnapsackDPComp}
```

零钱兑换问题

背包问题是一大类动态规划问题的代表，其拥有很多的变种，例如零钱兑换问题。

!!! question

给定 $n$ 种硬币，第 $i$ 种硬币的面值为 $coins[i - 1]$ ，目标金额为 $amt$ ，**每种硬币可以重复选取**，问能够凑出目标金额的最少硬币个数。如果无法凑出目标金额则返回 $-1$ 。

在这里插入图片描述

动态规划思路

零钱兑换可以看作是完全背包的一种特殊情况，两者具有以下联系与不同点。

  • 两道题可以相互转换，“物品”对应于“硬币”、“物品重量”对应于“硬币面值”、“背包容量”对应于“目标金额”。
  • 优化目标相反，背包问题是要最大化物品价值，零钱兑换问题是要最小化硬币数量。
  • 背包问题是求“不超过”背包容量下的解，零钱兑换是求“恰好”凑到目标金额的解。

第一步：思考每轮的决策，定义状态，从而得到 d p dp dp 表

状态 [ i , a ] [i, a] [i,a] 对应的子问题为：前 i i i 种硬币能够凑出金额 a a a 的最少硬币个数，记为 d p [ i , a ] dp[i, a] dp[i,a] 。

二维 d p dp dp 表的尺寸为 ( n + 1 ) × ( a m t + 1 ) (n+1) \times (amt+1) (n+1)×(amt+1) 。

第二步：找出最优子结构，进而推导出状态转移方程

本题与完全背包的状态转移方程存在以下两个差异。

  • 本题要求最小值，因此需将运算符 max ⁡ ( ) \max() max() 更改为 min ⁡ ( ) \min() min() 。
  • 优化主体是硬币数量而非商品价值，因此在选中硬币时执行 + 1 +1 +1 即可。

d p [ i , a ] = min ⁡ ( d p [ i − 1 , a ] , d p [ i , a − c o i n s [ i − 1 ] ] + 1 ) dp[i, a] = \min(dp[i-1, a], dp[i, a - coins[i-1]] + 1) dp[i,a]=min(dp[i−1,a],dp[i,a−coins[i−1]]+1)

第三步：确定边界条件和状态转移顺序

当目标金额为 0 0 0 时，凑出它的最少硬币个数为 0 0 0 ，即首列所有 d p [ i , 0 ] dp[i, 0] dp[i,0] 都等于 0 0 0 。

当无硬币时，无法凑出任意 > 0 > 0 >0 的目标金额，即是无效解。为使状态转移方程中的 min ⁡ ( ) \min() min() 函数能够识别并过滤无效解，我们考虑使用 + ∞ + \infty +∞ 来表示它们，即令首行所有 d p [ 0 , a ] dp[0, a] dp[0,a] 都等于 + ∞ + \infty +∞ 。

代码实现

大多数编程语言并未提供 + ∞ + \infty +∞ 变量，只能使用整型 int 的最大值来代替。而这又会导致大数越界：状态转移方程中的 + 1 + 1 +1 操作可能发生溢出。

为此，我们采用数字 a m t + 1 amt + 1 amt+1 来表示无效解，因为凑出 a m t amt amt 的硬币个数最多为 a m t amt amt 个。

最后返回前，判断 d p [ n , a m t ] dp[n, amt] dp[n,amt] 是否等于 a m t + 1 amt + 1 amt+1 ，若是则返回 − 1 -1 −1 ，代表无法凑出目标金额。

=== “Python”

```python title="coin_change.py"
[class]{}-[func]{coin_change_dp}
```

=== “C++”

```cpp title="coin_change.cpp"
[class]{}-[func]{coinChangeDP}
```

=== “Java”

```java title="coin_change.java"
[class]{coin_change}-[func]{coinChangeDP}
```

=== “C#”

```csharp title="coin_change.cs"
[class]{coin_change}-[func]{coinChangeDP}
```

=== “Go”

```go title="coin_change.go"
[class]{}-[func]{coinChangeDP}
```

=== “Swift”

```swift title="coin_change.swift"
[class]{}-[func]{coinChangeDP}
```

=== “JS”

```javascript title="coin_change.js"
[class]{}-[func]{coinChangeDP}
```

=== “TS”

```typescript title="coin_change.ts"
[class]{}-[func]{coinChangeDP}
```

=== “Dart”

```dart title="coin_change.dart"
[class]{}-[func]{coinChangeDP}
```

=== “Rust”

```rust title="coin_change.rs"
[class]{}-[func]{coin_change_dp}
```

=== “C”

```c title="coin_change.c"
[class]{}-[func]{coinChangeDP}
```

=== “Zig”

```zig title="coin_change.zig"
[class]{}-[func]{coinChangeDP}
```

下图展示了零钱兑换的动态规划过程，和完全背包非常相似。

=== “<1>”
在这里插入图片描述

=== “<2>”
在这里插入图片描述

=== “<3>”
在这里插入图片描述

=== “<4>”
在这里插入图片描述

=== “<5>”
在这里插入图片描述

=== “<6>”
在这里插入图片描述

=== “<7>”
在这里插入图片描述

=== “<8>”
在这里插入图片描述

=== “<9>”
在这里插入图片描述

=== “<10>”
在这里插入图片描述

=== “<11>”
在这里插入图片描述

=== “<12>”
在这里插入图片描述

=== “<13>”
在这里插入图片描述

=== “<14>”
在这里插入图片描述

=== “<15>”
在这里插入图片描述

空间优化

零钱兑换的空间优化的处理方式和完全背包一致。

=== “Python”

```python title="coin_change.py"
[class]{}-[func]{coin_change_dp_comp}
```

=== “C++”

```cpp title="coin_change.cpp"
[class]{}-[func]{coinChangeDPComp}
```

=== “Java”

```java title="coin_change.java"
[class]{coin_change}-[func]{coinChangeDPComp}
```

=== “C#”

```csharp title="coin_change.cs"
[class]{coin_change}-[func]{coinChangeDPComp}
```

=== “Go”

```go title="coin_change.go"
[class]{}-[func]{coinChangeDPComp}
```

=== “Swift”

```swift title="coin_change.swift"
[class]{}-[func]{coinChangeDPComp}
```

=== “JS”

```javascript title="coin_change.js"
[class]{}-[func]{coinChangeDPComp}
```

=== “TS”

```typescript title="coin_change.ts"
[class]{}-[func]{coinChangeDPComp}
```

=== “Dart”

```dart title="coin_change.dart"
[class]{}-[func]{coinChangeDPComp}
```

=== “Rust”

```rust title="coin_change.rs"
[class]{}-[func]{coin_change_dp_comp}
```

=== “C”

```c title="coin_change.c"
[class]{}-[func]{coinChangeDPComp}
```

=== “Zig”

```zig title="coin_change.zig"
[class]{}-[func]{coinChangeDPComp}
```

零钱兑换问题 II

!!! question

给定 $n$ 种硬币，第 $i$ 种硬币的面值为 $coins[i - 1]$ ，目标金额为 $amt$ ，每种硬币可以重复选取，**问在凑出目标金额的硬币组合数量**。

在这里插入图片描述

动态规划思路

相比于上一题，本题目标是组合数量，因此子问题变为：前 i i i 种硬币能够凑出金额 a a a 的组合数量。而 d p dp dp 表仍然是尺寸为 ( n + 1 ) × ( a m t + 1 ) (n+1) \times (amt + 1) (n+1)×(amt+1) 的二维矩阵。

当前状态的组合数量等于不选当前硬币与选当前硬币这两种决策的组合数量之和。状态转移方程为：

d p [ i , a ] = d p [ i − 1 , a ] + d p [ i , a − c o i n s [ i − 1 ] ] dp[i, a] = dp[i-1, a] + dp[i, a - coins[i-1]] dp[i,a]=dp[i−1,a]+dp[i,a−coins[i−1]]

当目标金额为 0 0 0 时，无须选择任何硬币即可凑出目标金额，因此应将首列所有 d p [ i , 0 ] dp[i, 0] dp[i,0] 都初始化为 1 1 1 。当无硬币时，无法凑出任何 > 0 >0 >0 的目标金额，因此首行所有 d p [ 0 , a ] dp[0, a] dp[0,a] 都等于 0 0 0 。

代码实现

=== “Python”

```python title="coin_change_ii.py"
[class]{}-[func]{coin_change_ii_dp}
```

=== “C++”

```cpp title="coin_change_ii.cpp"
[class]{}-[func]{coinChangeIIDP}
```

=== “Java”

```java title="coin_change_ii.java"
[class]{coin_change_ii}-[func]{coinChangeIIDP}
```

=== “C#”

```csharp title="coin_change_ii.cs"
[class]{coin_change_ii}-[func]{coinChangeIIDP}
```

=== “Go”

```go title="coin_change_ii.go"
[class]{}-[func]{coinChangeIIDP}
```

=== “Swift”

```swift title="coin_change_ii.swift"
[class]{}-[func]{coinChangeIIDP}
```

=== “JS”

```javascript title="coin_change_ii.js"
[class]{}-[func]{coinChangeIIDP}
```

=== “TS”

```typescript title="coin_change_ii.ts"
[class]{}-[func]{coinChangeIIDP}
```

=== “Dart”

```dart title="coin_change_ii.dart"
[class]{}-[func]{coinChangeIIDP}
```

=== “Rust”

```rust title="coin_change_ii.rs"
[class]{}-[func]{coin_change_ii_dp}
```

=== “C”

```c title="coin_change_ii.c"
[class]{}-[func]{coinChangeIIDP}
```

=== “Zig”

```zig title="coin_change_ii.zig"
[class]{}-[func]{coinChangeIIDP}
```

空间优化

空间优化处理方式相同，删除硬币维度即可。

=== “Python”

```python title="coin_change_ii.py"
[class]{}-[func]{coin_change_ii_dp_comp}
```

=== “C++”

```cpp title="coin_change_ii.cpp"
[class]{}-[func]{coinChangeIIDPComp}
```

=== “Java”

```java title="coin_change_ii.java"
[class]{coin_change_ii}-[func]{coinChangeIIDPComp}
```

=== “C#”

```csharp title="coin_change_ii.cs"
[class]{coin_change_ii}-[func]{coinChangeIIDPComp}
```

=== “Go”

```go title="coin_change_ii.go"
[class]{}-[func]{coinChangeIIDPComp}
```

=== “Swift”

```swift title="coin_change_ii.swift"
[class]{}-[func]{coinChangeIIDPComp}
```

=== “JS”

```javascript title="coin_change_ii.js"
[class]{}-[func]{coinChangeIIDPComp}
```

=== “TS”

```typescript title="coin_change_ii.ts"
[class]{}-[func]{coinChangeIIDPComp}
```

=== “Dart”

```dart title="coin_change_ii.dart"
[class]{}-[func]{coinChangeIIDPComp}
```

=== “Rust”

```rust title="coin_change_ii.rs"
[class]{}-[func]{coin_change_ii_dp_comp}
```

=== “C”

```c title="coin_change_ii.c"
[class]{}-[func]{coinChangeIIDPComp}
```

=== “Zig”

```zig title="coin_change_ii.zig"
[class]{}-[func]{coinChangeIIDPComp}
```
白话机器学习
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
【动态规划之背包问题】——完全背包问题（518. 零钱兑换 II）
your_棒棒糖的博客
03-28 184
完全背包问题 518. 零钱兑换 II 题目描述 给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。 示例 1: 输入: amount = 5, coins = [1, 2, 5] 输出: 4 解释: 有四种方式可以凑成总金额: 5=5 5=2+2+1 5=2+1+1+1 5=1+1+1+1+1 示例 2: 输入: amount = 3, coins = [2] 输出: 0 解释: 只用面额2的硬币不能凑成总金额3。 示例 3: 输入: amount =
Java面试基础宝典
weixin_45388641的博客
09-06 732
一.基础知识： 1）集合类：List和Set比较，各自的子类比较（ArrayList，Vector，LinkedList；HashSet，TreeSet）； ArrayList，LinkedList，Vector都属于List List：元素是有顺序的，元素可以重复因为每个元素有自己的角标（索引） |-- ArrayList:底层的数据结构是数组结构，特点是：查询很快，增 删 稍微慢点，线程不同步...
C#用递归算法解决经典背包问题
12-25
1.引子 　　我们人类是一种贪婪的动物，如果给您一个容量一定的背包和一些大小不一的物品，裝到背包里面的物品就归您，遇到这种好事大家一定不会错过，用力塞不一定是最好的办法，用脑子才行，下面就教您如何解决这样的问题，以获得更多的奖品。 2.应用场景 　　在一个物品向量中找到一个子集满足条件如下 ： 　　1）这个子集加起来的体积大小不能大于指定阀值 　　2）这个物品子集加起来价值大小是向量V中所有满足条件1的子集中最大的 3.分析 　　背包问题有好多版本，本文只研究0/1版本，即对一个物体要么选用，要么就抛弃，不能将一个物体再继续细分的情况。这种问题最简单的方法就是找出这个向量的所有子集，如同找出幂
零钱兑换Ⅱ（典型的完全背包问题（完全背包降维的时候和普通背包是不同的））
ShenHang_的博客
04-12 249
不用多说，直接上代码： class Solution { public: int change(int amount, vector<int>& coins) { //dp[i][j]当前背包容量 j，前 i 个物品最佳组合对应的价值 //即只使用前i个面值，若想凑出金额j，有dp[i][j]种凑法 int N = coins.size(); vector&...
[Swift 开发] 01背包问题
u010130947的专栏
08-08 305
有N件物品和一个容量是V的背包。每件物品只能使用一次。 第i件物品的体积是vi，价值是wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 滚动数组解法 每件物品只能选一次，对于每种物品，我们有两种选择 1.不选 -> dp[i][j]=dp[i-1][j] 等于选前i-1个物品，空间为j情况下的最优解 2.选 -> dp[i][j]=dp[i-1][j-v[i]]+w[i] 如果选的话，前i-1个物品的体积最多为j-v[i] ...
完全背包问题
不管风雨有多少丶的博客
03-14 111
#include<cstdio> #include<queue> #include<algorithm> using namespace std; const int maxn=100; const int maxv=1000; int dp[maxv],n,c[maxn],w[maxn]; int main(){ // for(int i=1;i<=n...
算法导论——Introduction to Algorithms
12-03
从排序算法（如快速排序、归并排序）、搜索算法（如二分查找）、图算法（如Dijkstra最短路径算法）、动态规划（如背包问题）、贪心算法到NP完全问题等，几乎覆盖了所有重要的算法类型和设计策略。此外，还探讨了算法...
各大IT公司校园招聘程序猿笔试、面试题集锦
热门推荐
Hackbuteer1的专栏
09-09 4万+
百度一面 1、给定一个字符串比如“abcdef”，要求写个函数编程“defabc”，位数是可变的。这个比较简单，我用的是strcpy和memcpy，然后他问有什么优化的办法，我就不知道了。 2、socket过程就是socket的server和client整个流程写下来，这个还是没啥问题的。 3、数据结构二叉树的遍历，给了个二叉树，前序、中序、后序写出来，这个没什么难度。 http://
web前端进阶大厂面试资料合集
m0_67537062的博客
03-26 1480
最近整理了下web前端面试的资料，包含了web前端、数据结构和算法、计算机基础、版本控制工具、经验分享、视频课程和面试书籍等资料，还有比这更全的没有？ 废话不多说，直接上干货，欢迎收藏，不用客气。 前端 面试官求你别再问我hook了 前端开发技术面试指南及真题讲解带你入坑BAT 一线大厂前端面试题年末大汇总 web企业面试题精讲 2年前端(外包经历) 6月部分面试记录 （高级、资深岗位） 三十七个常见Vue面试题，背就完事了 看过 100 份前端简历之后，汇总一下常见的问题 2021
最全153道Spring全家桶面试题，中国邮政储蓄银行java开发
m0_57286622的博客
05-15 961
前言 要相信，你现在所有的努力和付出都会在将来的某一天回报给你！ 首先阿里巴巴作为国内互联网行业的领头羊，培养了一代又一代的IT技术人才，很多想进阿里这些互联网大厂的程序员看中的不仅仅是高薪+丰厚的福利待遇，同样也看中了学习氛围以及人脉圈子，这些资源在你以后对你来说都将是一笔财富。 如果你想进大厂，一定是要求自身技术栈能达到企业的需求甚至超过企业的需求，关于技术如何提升的问题，一直以来都备受关注，IT行业发展的很快，程序员要保持不断学习，因此，就算是相同起点的人，经过几年的工作或学习，会迅速拉开极大的差
完全背包问题实例
weixin_30631587的博客
11-15 213
题目描述 零崎有很多朋友，其中有一个叫做lfj的接盘侠。 lfj是一个手残，他和零崎一起玩网游的时候不好好打本，天天看拍卖行，没过多久，就成为了一个出色的商人。时间一长，虽然挣了不少钱，却没时间练级了。 作为lfj的友人，零崎实在看不下去，于是他决定帮lfj一把。当然了，零崎肯定不会自己动手，活还得你们来干。 lfj可以提供给你们拍卖行所有能买到物品的价格和利润，由于游戏产出不限，所以可以...
算法与数据结构面试宝典——01背包问题
最新发布
白话机器学习
09-16 198
背包问题是一个非常好的动态规划入门题目，是动态规划中最常见的问题形式。其具有很多变种，例如 0-1 背包问题、完全背包问题、多重背包问题等。在本节中，我们先来求解最常见的 0-1 背包问题。!!!question观察下图，由于物品编号i从1开始计数，数组索引从0开始计数，因此物品i对应重量wgti−1和价值vali−1。我们可以将 0-1 背包问题看作是一个由n轮决策组成的过程，每个物体都有不放入和放入两种决策，因此该问题是满足决策树模型的。
背包问题-贪心算法
千尺浪的博客
10-20 396
背包空间：50 三个物品 n                 1           2                3 重量        10           20             30 价值        60           100           120 性价比    6              5                4 当作背包问
hihocoder1043 完全背包 完全背包的几种写法
旧时光
05-26 1643
题目链接： hiho1043 二维： #include #include #include #define MAXN 505 using namespace std; int dp[505][100005]; int need[505]; int value[505]; int main() { int n,v;
01背包问题和完全背包问题难点详解
weixin_54398380的博客
01-21 3489
本文主要是用于复习，了解动态规划但是经常记不住要如何使用，以及为社么要这样用，不太适合刚学习动态规划的人。
完全背包问题(详细解答)
weixin_46503238的博客
03-22 2万+
首先完全背包问题需要01背包问题做铺垫,如果读者01背包问题没有解决,一定要理解之后,在看完全背包问题,包括01背包的优化! 这里是01背包 这里是01背包的全部优化 好,我们开始完全背包! 完全背包定义 有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的体积是v[i]，价值是val[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 从定义中可以看出,与01背包的区别01背包最多只能拿一件物品,完全背包则不然,只要空间够多,一种物品我可以拿n件! 01
经典背包问题 01背包+完全背包+多重背包
LYHVOYAGE的专栏
04-06 3万+
01 背包 有n 种不同的物品，每个物品有两个属性，size 体积，value 价值，现在给一个容量为 w 的背包，问最多可带走多少价值的物品。           int f[w+1];   //f[x] 表示背包容量为x 时的最大价值           for (int i=0; i             for (int j=w; j>=size[i]; j--)
疯子的算法总结(四）贪心算法
日拱一卒,功不唐捐
03-13 2651
一、在求最优解问题的过程中，依据某种贪心标准，从问题的初始状态出发，直接去求每一步的最优解，通过若干次的贪心选择，最终得出整个问题的最优解，这种求解方法就是贪心算法。 二、贪心条件：含有最优子结构。 三、利用贪心解决问题的关键需要考虑如何选取贪心标准。 四、适用题型 1.活动选择问题。 这层楼沿着走廊南北向的两边各有200个房间。最近，公司要做一次装修，需要在各个办公室之间搬运办公桌。由于走廊狭窄...
LeetCode刷题宝典：数据结构与算法核心技巧详解
《数据结构与算法 LeetCode刷题宝典V1.0》是一本由华北电力大学（保定）的马燕鹏编撰的150多页的学习资料，旨在帮助读者掌握和提升在数据结构与算法方面的能力，特别适合那些准备学习或备考计算机类研究生的学生。...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

白话机器学习

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值