_39LeetCode代码随想录算法训练营第三十九天-动态规划完全背包 | 70.爬楼梯、322.零钱兑换、279.完全平方数

_39LeetCode代码随想录算法训练营第三十九天-动态规划完全背包 | 70.爬楼梯、322.零钱兑换、279.完全平方数

题目列表

• 70.爬楼梯（进阶）
• 322.零钱兑换
• 279.完全平方数

70.爬楼梯（进阶）

代码随想录地址：https://programmercarl.com/0070.%E7%88%AC%E6%A5%BC%E6%A2%AF%E5%AE%8C%E5%85%A8%E8%83%8C%E5%8C%85%E7%89%88%E6%9C%AC.html#%E6%80%9D%E8%B7%AF

题目

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

示例 1：

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

示例 2：

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

提示：

• 1 <= n <= 45

思路

可以抽象为一个完全背包问题，背包的最大容量问楼梯的阶数n，物品为1、2(分别表示1步或2步)。并且是一个排列问题，因为1、2和2、1到3楼的是不一样的。

动态规划五部曲：

• dp数组的含义

爬到i层，有dp[i]种方法。

• 确定递推公式

dp[i] += dp[i - j] //类似于组合和排列的递推公式，因为是求方法的种类。

• dp数组的初始化

dp[0] = 1;//仅仅是为了递推公式正常执行。

//也可以说到达0层有1种方法。

• 遍历顺序

由于是排列问题，因此外层循环是背包，内层循环是步数。

• dp数组的动态演示

草稿纸上完成。

代码

/*
 * @lc app=leetcode.cn id=70 lang=cpp
 *
 * [70] 爬楼梯
 */

// @lc code=start
class Solution {
public:
    int climbStairs(int n) {
        int m = 2;
        //定义dp数组
        vector<int> dp(n + 1, 0);
        //初始化dp数组
        dp[0] = 1;
        //遍历
        for(int j = 0; j <= n; j++)
            for(int i = 1; i <= 2; i++)//此处可以扩展到1、2、3步及以上步，将2改为n步就行
                if(j - i >= 0)
                    dp[j] += dp[j - i];
        return dp[n];
    }
};
// @lc code=end

322.零钱兑换

代码随想录地址：https://programmercarl.com/0322.%E9%9B%B6%E9%92%B1%E5%85%91%E6%8D%A2.html

题目

给你一个整数数组 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] <= $2^{31}$ - 1
• 0 <= amount <= $10^4$

思路

动规五部曲：

• 确定dp数组以及下标的含义

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

• 确定递推公式

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

• 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;

• 确定遍历顺序

本题求钱币最小个数，那么钱币有顺序和没有顺序都可以，都不影响钱币的最小个数。

所以本题并不强调集合是组合还是排列，但是求组合的时间复杂度低一些。

求组合：外层循环为物品，内层循环为背包。

求排列：外层循环为背包，内层循环为物品。

由于是完全背包题目，因此遍历顺序为从小到大。

• dp数组动态推导

草稿纸完成。

代码

/*
 * @lc app=leetcode.cn id=322 lang=cpp
 *
 * [322] 零钱兑换
 */

// @lc code=start
class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        //定义dp数组
        vector<int> dp(amount + 1, INT_MAX);
        //dp数组初始化
        dp[0] = 0;//表示凑成0有0种方案
        //遍历
        for(int data : coins)
            for(int j = data; j <= amount; j++)
                if(dp[j - data] != INT_MAX)//如果不加这个条件的 话dp[j - data] + 1会溢出
                    dp[j] = min(dp[j], dp[j - data] + 1);
        //这种情况返回-1，就是说没有凑成
        if(dp[amount] == INT_MAX)
            return -1;
        return dp[amount];
    }
};
// @lc code=end

279.完全平方数

代码随想录地址：https://programmercarl.com/0279.%E5%AE%8C%E5%85%A8%E5%B9%B3%E6%96%B9%E6%95%B0.html

题目

给你一个整数 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$

动态规划思路

思路

• dp数组的含义

dp[j]表示和为j的完全平方数的最少数量 。

• 递推公式

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

• dp数组初始化

dp[0] = 0;//表示和为0的完全平方数的最小数量为0。

其他元素赋值为INT_MAX，保证初值不会覆盖递推过程产生的值。

• 遍历顺序

是完全背包，遍历顺序都是从小到大。

外层循环为遍历物品，内层循环遍历背包，以求得组合个数；相比于求得排列个数时间复杂度低。

• 动态推导dp

草稿纸上完成。

代码

/*
 * @lc app=leetcode.cn id=279 lang=cpp
 *
 * [279] 完全平方数
 */

// @lc code=start
class Solution {
public:
    int numSquares(int n) {
        //定义及初始化dp数组
        vector<int> dp(n + 1, INT_MAX);
        dp[0] = 0;
        //遍历
        for(int i = 1; i * i <= n; i++)
            for(int j = i * i; j <= n; j++)
                if(dp[j - i * i] + 1 <= INT_MAX)
                    dp[j] = min(dp[j], dp[j - i*i] + 1);
        return dp[n];
    }
};
// @lc code=end

数学思路

思路

数学定理：

1. 任何正整数都可以拆分成不超过4个数的平方和 —> 答案只可能是1,2,3,4
2. 如果一个数最少可以拆成4个数的平方和，则这个数还满足 n = (4^a)*(8b+7) —> 因此可以先看这个数是否满足上述公式，如果不满足，答案就是1,2,3了
3. 如果这个数本来就是某个数的平方，那么答案就是1，否则答案就只剩2,3了
4. 如果答案是2，即n=a^2+b2，那么我们可以枚举a，来验证，如果验证通过则答案是2
5. 只能是3

代码

/*
 * @lc app=leetcode.cn id=279 lang=cpp
 *
 * [279] 完全平方数
 */

// @lc code=start
class Solution {
public:
    int numSquares(int n) {
        //验证公式n = (4^a)*(8b+7) ，如果满足，则是4个数
        while n % 4 == 0: 
            n /= 4 
        if n % 8 == 7: 
            return 4 
        a = 0
        //判断答案是否为1和2
        while a**2 <= n: 
            b = int((n - a**2)**0.5) 
            if a**2 + b**2 == n: 
                return (not not a) + (not not b) 
            a += 1 
        //前面都不满足，就是3
        return 3
    }
};
// @lc code=end