动态规划之完全背包问题

完全背包问题

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 <stdio.h>
#include <iostream>
#include <string.h>
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>& coins, int amount) {
        int n = coins.size();
        vector<vector<int>> dp(n + 1, vector<int>(amount + 1));

        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<int> v;
        for (int i = 1; i * i <= n; ++i)
            v.push_back(i * i);
            
        int m = v.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        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<string>& strs, int m, int n) {
        int x = strs.size(); //有x个字符串
        vector<vector<vector<int>>> dp(x + 1, vector<vector<int>>(m + 1, vector<int>(n + 1))); 
        //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];
    }
};