算法-动态规划-背包问题-322. 零钱兑换+（背包问题小结）+完全平方数-C++

---

来源

力扣题目链接
原创文章链接

问题

题目难度：中等
给定不同面额的硬币 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
示例 4：

输入：coins = [1], amount = 1
输出：1
示例 5：

输入：coins = [1], amount = 2
输出：2
提示：

1 <= coins.length <= 12
1 <= coins[i] <= 2^31 - 1
0 <= amount <= 10^4

思路

问题分析：

这次兑换零钱是寻求最小的做法，和之前有多少种做法不同，这个的遍历顺序
使用动规五部曲分析：

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

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

dp[j]：凑足总额为j所需钱币的最少个数为dp[j]

2. 确定递推公式

凑足总额为j - coins[i]的最少个数为dp[j - coins[i]]，那么只需要加上一个钱币coins[i]即dp[j - coins[i]] + 1就是dp[j]（考虑coins[i]）

所以dp[j] 要取所有 dp[j - coins[i]] + 1 中最小的。

递推公式：dp[j] = min(dp[j - coins[i]] + 1, dp[j]);

3. dp数组如何初始化

首先凑足总金额为0所需钱币的个数一定是0，那么dp[0] = 0;

其他下标对应的数值呢？

考虑到递推公式的特性，dp[j]必须初始化为一个最大的数，否则就会在min(dp[j - coins[i]] + 1, dp[j])比较的过程中被初始值覆盖。

所以下标非0的元素都是应该是最大值。

代码如下：

vector<int> dp(amount + 1, INT_MAX);
dp[0] = 0;

4. 确定遍历顺序

外层for循环遍历物品，内层for遍历背包或者外层for遍历背包，内层for循环遍历物品都是可以的！

5. 举例推导dp数组

以输入：coins = [1, 2, 5], amount = 5为例

C++代码如下：

// 版本一
class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        vector<int> dp(amount + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 0; i < coins.size(); i++) { // 遍历物品
            for (int j = coins[i]; j <= amount; j++) { // 遍历背包
                if (dp[j - coins[i]] != INT_MAX) { // 如果dp[j - coins[i]]是初始值则跳过
                    dp[j] = min(dp[j - coins[i]] + 1, dp[j]);
                }
            }
        }
        if (dp[amount] == INT_MAX) return -1;
        return dp[amount];
    }
};

这种解法有趣的地方就在于，它限制你放物品的大小的时候就已经默认为你已经放进去一次了，所以能在每次循环加1的时候取得最好的效果，对于是取最大值还是，最小值来讲取决于你的筛选。非常不好想，对于多少种放东西方法这个问题，dp[j]+=dp[j-num[i]],由于从一开始循环时的限制，能很好的进行初始化。
对于放这个东西最少硬币来讲，直接无脑循环dp[i] = min(dp[i - coins[j]] + 1, dp[i]);确保每一层都是最小组合方式。

总结

1. 01背包问题：最大能装满多少

 dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

2. 装满有多少种方法问题

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

3. 最少有几个物品能装满

dp[j] = min(dp[j - coins[i]] + 1, dp[j]);

4. 组合数就是不允许有重复，一般是先遍历物品再遍历背包容量

        for (int i = 0; i < coins.size(); i++) { // 遍历物品
            for (int j = coins[i]; j <= amount; j++) { // 遍历背包
                if (dp[j - coins[i]] != INT_MAX) { // 如果dp[j - coins[i]]是初始值则跳过
                    dp[j] = min(dp[j - coins[i]] + 1, dp[j]);
                }
            }
        }

5. 排列数是允许有重复，外层for遍历背包，内层for循环遍历物品。

for (int i = 0; i <= target; i++) { // 遍历背包
            for (int j = 0; j < nums.size(); j++) { // 遍历物品
                if (i - nums[j] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]]) {//注意这里添加了一个判断，背包容量大于物品
                    dp[i] += dp[i - nums[j]];
                }
            }

01背包问题不允许无限多，背包的循环是从大到小，完全背包允许无限多，是从小到大

问题2：完全平方数

题目难度：中等
给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。

给你一个整数 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 <= 10^4

思路

问题分析：

同上面问题答题方式一样，唯一的不同就是nums[i]换成了j*j，巧妙地替换达成要求。

// 版本一
class Solution {
public:
    int numSquares(int n) {
        vector<int> dp(n + 1, INT_MAX);
        dp[0] = 0;
        for (int i = 0; i <= n; i++) { // 遍历背包
            for (int j = 1; j * j <= i; j++) { // 遍历物品
                dp[i] = min(dp[i - j * j] + 1, dp[i]);
            }
        }
        return dp[n];
    }
};