完全背包问题
1. 完全背包2. 零钱兑换3. 完全平方数4. 一和零
完全背包问题（Complete Knapsack Problem）是指给定一组物品，每种物品都有自己的重量和价值，物品数量无限。问题是如何选择物品放入背包，使得背包内物品的总重量不超过背包容量，同时尽可能获得最大的价值。它可以选择取0件、取1件、取2件……取k件，而0/1背包问题只能取0件、取1件。在完全背包问题中，物品不止有一个，也分两种，一种是不作任何限制，要多少有多少，这种称为完全背包问题，另一种是依然有个数限制，这种称为多重背包问题。在动态规划算法中，我们枚举所有状态和决策，获得所有的状态转移，并且记录这个过程中每个状态能够获得的最优解。完全背包问题是0/1背包问题的无限制版，从原理上来说，两者的思路和做法基本上是一样的。对于完全背包问题，我们同样可以采用动态规划算法来解决。 与0/1背包问题不同的是，在完全背包问题中，每一个物品可以选择装入多次，因此需要重新定义状态和转移方程。 定义状态：用dp [i] [j]表示前i个物品，容量为j时的最大价值。 状态转移方程：对于第i个物品，我们可以选择装入它或不装入它。 如果选择装入它，则背包容量会减少w [i-1]，同时总价值加上v [i-1]。 如果选择不装入它，则背包容量不变，总价值不变。 因此，我们可以得到状态转移方程：
dp [i] [j] = max(dp [i-1] [j], dp [i] [j-w [i-1]] + v [i-1])。
1. 完全背包
1.题目链接：【模板】完全背包 2.题目描述： 你有一个背包，最多能容纳的体积是V。
现在有n种物品，每种物品有任意多个，第i种物品的体积为vi,价值为wi 。 （1）求这个背包至多能装多大价值的物品？ （2）若背包恰好装满，求至多能装多大价值的物品？
输入描述： 第一行两个整数n和V，表示物品个数和背包体积。 接下来n行，每行两个数vi和wi ，表示第i种物品的体积和价值。 1≤n,V≤1000 输出描述： 输出有两行，第一行输出第一问的答案，第二行输出第二问的答案，如果无解请输出0。
示例1
输入： 2 6 5 10 3 1 输出： 10 2
示例2
输入： 3 8 3 10 9 1 10 1 输出： 20 0 说明： 无法恰好装满背包。
示例3
输入： 6 13 13 189 17 360 19 870 14 184 6 298 16 242 输出： 596 189 说明：可以装5号物品2个，达到最大价值298*2=596，若要求恰好装满，只能装1个1号物品，价值为189.
3.问题分析：
状态表⽰：dp[i][j] 表示：从前 i 个物品中挑选，总体积不超过 j ，所有的选法中，能挑选出来的最⼤价值。状态转移方程：将这道题(完全背包)和0/1背包问题进行类比，其中0/1背包是物品只能选择一次，而完全背包问题可以选择多次，对于 i 位置的物品来说，如果 i 位置的物品被选择的话，那么我们就只能选择 i 位置之前的物品，即dp[i - 1]，dp表表示的就是能挑选出来的最⼤价值， 那么dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i])，而完全背包的关键之处就在于 i 位置的物品可以选多次，如果 i 位置的物品被选，则 i 位置的物品还是可以选择的，即dp[i]，那么状态转移方程为dp[i][j] = max(dp[i][j], dp[i][j-w[i]] + v[i])。初始化：因为对于求 i，j 位置的值需要知道 i - 1，j - w[i]位置的值，根据以往的经验，可以多设置一行和一列，防止越界访问。对第一问来说，装不了的物品就dp位置设置为0，所以全部初始化为0即可。而对于第二问来说，没装满的位置设置为-1，所以需要细分一下：dp表的第一行表示的是背包的个数为0–n个，而物品的体积为0，所以除了0,0位置刚好装满其余没装满，即除了0,0位置为0，其余位置初始化为-1；dp表的第一列表示的是物品的体积为0，而背包的个数为0–n个，所以全初始化为0。填表顺序：从左往右，从上到下依次填写。返回值：返回dp[n][v]位置的值，第二问dp[n][v]可能是-1，所以在这判断一下，如果为-1，返回0。
#include
#include
#include
using namespace std;
const int N = 1010;
int n, V, v[N], w[N];
int dp[N][N];
int main()
{
cin >> n >> V;
for (int i = 1; i <= n; ++i)
cin >> v[i] >> w[i];
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= V; ++j)
{
dp[i][j] = dp[i - 1][j];
if (j >= v[i])
dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
}
}
cout << dp[n][V] << endl;
memset(dp, 0, sizeof dp); // 将dp表进行清零
for (int j = 1; j <= V; ++j)
dp[0][j] = -1;
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= V; ++j)
{
dp[i][j] = dp[i - 1][j];
if (j >= v[i] && dp[i][j - v[i]] != -1)
dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
}
}
cout << (dp[n][V] == -1 ? 0 : dp[n][V]) << endl;
return 0;
}
2. 零钱兑换
1.题目链接：零钱兑换 2.题目描述： 给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。 计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。 你可以认为每种硬币的数量是无限的。
示例 1：
输入：coins = [1, 2, 5], amount = 11 输出：3 解释：11 = 5 + 5 + 1
示例 2：
输入：coins = [2], amount = 3 输出：-1
示例 3：
输入：coins = [1], amount = 0 输出：0
提示：
1 <= coins.length <= 12 1 <= coins[i] <= 231 - 1 0 <= amount <= 104
3.问题分析：
状态表⽰：dp[i][j] 表⽰：从前 i 个硬币中挑选，总和正好等于 j ，所有的选法中，最少的硬币个数。状态转移方程：选 0 个第 i 个硬币：此时相当于就是去前 i - 1 个硬币中挑选，总和正好等于 j 。此时最少的硬币个数为 dp[i - 1][j] ；选 1 个第 i 个硬币：此时相当于就是去前i - 1 个硬币中挑选，总和正好等于 j -v[i] 。因为挑选了⼀个 i 硬币，此时最少的硬币个数为 dp[i - 1][j - coins[i]] + 1；结合在完全背包⾥⾯的思路，最终得到的状态转移⽅程为：dp[i][j] = min(dp[i - 1][j], dp[i][j - coins[i]] + 1) 。初始化：初始化第⼀⾏即可。这⾥因为取 min ，所以我们可以把⽆效的地⽅设置成⽆穷⼤ (0x3f3f3f3f) 因为这⾥要求正好凑成总和为 j ，因此，需要把第⼀⾏除了第⼀个位置的元素，都设置成⽆穷⼤。填表顺序：根据状态转移⽅程，需从上往下填表。返回值：如果dp[n][v]=0x3f3f3f3f，则返回-1,；否则返回dp[n][v]。
4.代码如下：
class Solution {
public:
const int INF = 0x3f3f3f3f;
int coinChange(vector
int n = coins.size();
vector
for (int j = 1; j <= amount; ++j)
dp[0][j] = INF;
for (int i = 1; i <= n; ++i)
{
for (int j = 0; j <= amount; ++j)
{
dp[i][j] = dp[i - 1][j];
if (j >= coins[i - 1])
dp[i][j] = min(dp[i][j], dp[i][j - coins[i - 1]] + 1);
}
}
return dp[n][amount] >= INF ? -1 : dp[n][amount];
}
};
3. 完全平方数
1.题目链接：完全平方数 2.题目描述： 给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。
完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。
示例 1：
输入：n = 12 输出：3 解释：12 = 4 + 4 + 4
示例 2：
输入：n = 13 输出：2 解释：13 = 4 + 9
提示：
1 <= n <= 104
3.问题分析： 我们可以先将 1 2 3 4 6 等等这些数的最⼩数量依次保存起来。再求较⼤的 n 的时候，直接查表，然后找出最⼩数量。
状态表示：状态表⽰：dp[i] 表⽰：和为 i 的完全平⽅数的最少数量。状态转移方程：有完全背包的思路，可以容易的得到dp[i][j] = min(dp[i][j], dp[i][j - v[i - 1]] + 1);初始化：初始化第⼀⾏即可。这⾥因为取 min ，所以我们可以把⽆效的地⽅设置成⽆穷⼤ (0x3f3f3f3f) 因为这⾥要求正好凑成总和为 j ，因此，需要把第⼀⾏除了第⼀个位置的元素，都设置成⽆穷⼤。填表顺序：根据状态转移⽅程，需从上往下填表。返回值：返回dp[m][n]。
4.代码如下：
class Solution
{
public:
const int INF = 0x3f3f3f3f;
int numSquares(int n)
{
vector
for (int i = 1; i * i <= n; ++i)
v.push_back(i * i);
int m = v.size();
vector
for (int j = 1; j <= n; ++j)
dp[0][j] = INF;
for (int i = 1; i <= m; ++i)
{
for (int j = 0; j <= n; ++j)
{
dp[i][j] = dp[i - 1][j];
if (j >= v[i - 1])
dp[i][j] = min(dp[i][j], dp[i][j - v[i - 1]] + 1);
}
}
return dp[m][n];
}
};
4. 一和零
1.题目链接：一和零 2.题目描述： 给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。
如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。
示例 1：
输入：strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3 输出：4 解释：最多有5 个 0 和 3 个 1 的最大子集是 {“10”,“0001”,“1”,“0”} ，因此答案是 4 。 其他满足题意但较小的子集包括{“0001”,“1”} 和 {“10”,“1”,“0”} 。{“111001”} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3。
示例 2：
输入：strs = [“10”, “0”, “1”], m = 1, n = 1 输出：2 解释：最大的子集是 {“0”, “1”}，所以答案是 2 。
提示：
1 <= strs.length <= 600 1 <= strs[i].length <= 100 strs[i] 仅由 ‘0’ 和’1’ 组成 1 <= m, n <= 100
3.问题分析：
状态表⽰：dp[i][j][k] 表⽰：从前 i 个字符串中挑选，字符 0 的个数不超过 j ，字符 1 的个数不超过 k ，所有的选法中，最⼤的⻓度。状态转移⽅程： 线性 dp 状态转移⽅程分析⽅式，⼀般都是根据最后⼀步的状况，来分情况讨论。记第 i 个字符中，字符 0 的个数为 a ，字符 1 的个数为 b ： i. 不选第 i 个字符串：相当于就是去前 i - 1 个字符串中挑选，并且字符 0 的个数不超过 j ，字符 1 的个数不超过 k 。此时的最⼤⻓度为 dp[i][j][k] = dp[i - 1][j][k] ； ii. 选择第 i 个字符串：那么接下来我仅需在前 i - 1 个字符串⾥⾯，挑选出来字符 0 的个数不超过 j - a ，字符1的个数不超过 k - b 的最⻓⻓度，然后在这个⻓度后⾯加上字符串 i 即可。此时 dp[i][j][k] = dp[i - 1][j - a][k - b] + 1 。但是这种状态不⼀定存在，因此需要特判⼀下。综上，状态转移⽅程为： dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - a][k - b] + 1)。初始化：当没有字符串的时候，没有⻓度，因此初始化为 0 即可。填表顺序：保证第⼀维的循环从⼩到⼤即可。返回值：根据状态表⽰，我们返回 dp[len][m][n] 。其中 len 表⽰字符串数组的⻓度
4.代码如下：
class Solution {
public:
int findMaxForm(vector
int x = strs.size(); //有x个字符串
vector
//dp[x + 1][m + 1][n + 1]
for (int i = 1; i <= x; ++i)
{
//统计'0'和'1'出现的次数
int a = 0, b = 0;
for (auto& ch : strs[i - 1])
{
if (ch == '0')
++a;
else
++b;
}
for (int j = 0; j <= m; ++j)
{
for (int k = 0; k <= n; ++k)
{
dp[i][j][k] = dp[i - 1][j][k];
if (j >= a && k >= b)
dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - a][k - b] + 1);
}
}
}
return dp[x][m][n];
}
};
相关阅读
发表评论