代码随想录算法训练营第三十七天|518.零钱兑换II 377. 组合总和 Ⅳ 70. 爬楼梯 （进阶）

518.零钱兑换II

题目：

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。 

题目数据保证结果符合 32 位带符号整数。

示例 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 = 10, coins = [10] 
输出：1

提示：

• 1 <= coins.length <= 300
• 1 <= coins[i] <= 5000
• coins 中的所有值 互不相同
• 0 <= amount <= 5000

思路：

解决这个问题的思路是使用动态规划来计算可以凑成总金额的硬币组合数。

我们可以将这个问题视为一个“完全背包问题”，其中每种硬币的数量是无限的。

动态规划解法

1. 定义状态：

   • 用 dp[i] 表示金额 i 的硬币组合数。

2. 状态转移方程：

   • 对于每个硬币 coin，我们需要更新所有大于等于 coin 的金额。具体来说，如果我们已经知道了金额 i 的组合数 dp[i]，那么对于金额 i + coin，就有 dp[i + coin] += dp[i]，因为只要我们再加一个面额为 coin 的硬币，就可以从 i 变成 i + coin。

3. 初始化：

   • 由于凑成金额为 0 的唯一方式是使用 0 个硬币，因此 dp[0] = 1。

4. 计算顺序：

   • 先遍历每一种硬币，再遍历金额。

上代码：

class Solution {
public:
    int change(int amount, vector& coins) {
        vector dp(amount + 1, 0);
        dp[0] = 1; // 凑成金额0的唯一方式是使用0个硬币
        
        for (const int& coin : coins) { // 遍历每个硬币
            for (int i = coin; i <= amount; ++i) { // 遍历所有从coin到amount的金额
                dp[i] += dp[i - coin];
            }
        }
        
        return dp[amount];
    }
};

377. 组合总和 Ⅳ

题目：

给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

题目数据保证答案符合 32 位整数范围。

示例 1：

输入：nums = [1,2,3], target = 4
输出：7
解释：
所有可能的组合为：
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)
请注意，顺序不同的序列被视作不同的组合。

示例 2：

输入：nums = [9], target = 3
输出：0

提示：

• 1 <= nums.length <= 200
• 1 <= nums[i] <= 1000
• nums 中的所有元素 互不相同
• 1 <= target <= 1000

思路：

这个问题是一个典型的“完全背包问题”变形，求解的是所有的排列数目（考虑顺序）。

动态规划解法思路

1. 定义状态：

   • 用 dp[i] 表示凑成总和为 i 的组合数。

2. 状态转移方程：

   • 对于每一个目标值 i，我们遍历每个数字 num，如果 i >= num，则 dp[i] 的新值应该加上 dp[i - num]。也就是说，如果我们要凑成 i，并且使用了 num，那么剩下的部分就是 i - num，它的组合数已经在 dp[i - num] 中计算过了。

3. 初始化：

   • dp[0] = 1。因为凑成总和为 0 的唯一方法就是不选择任何数字，所以组合数是 1。

4. 计算顺序：

   • 需要注意这里的计算顺序：要按照从小到大的顺序依次计算 dp[1], dp[2], ..., dp[target]，这样每次计算时，所有可能用到的子问题解（dp[i - num]）已经被计算出来。

上代码：

class Solution {
public:
    int combinationSum4(vector& nums, int target) {
        vector dp(target + 1, 0);  // 使用 long long 来避免溢出
        dp[0] = 1;  // 基础情况：凑成总和为0的方法只有一种，就是不使用任何数字

        for (int i = 1; i <= target; ++i) {
            for (int num : nums) {
                if (i >= num) {
                    dp[i] += dp[i - num];
                    // 检查是否溢出
                    if (dp[i] > INT_MAX) {
                        dp[i] = INT_MAX;  // 如果溢出，将其设为最大值
                    }
                }
            }
        }

        return static_cast(dp[target]);  // 最终结果转换为 int 类型
    }
};

70. 爬楼梯 （进阶）

题目：

题目描述

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

每次你可以爬至多m (1 <= m < n)个台阶。你有多少种不同的方法可以爬到楼顶呢？ 

注意：给定 n 是一个正整数。

输入描述

输入共一行，包含两个正整数，分别表示n, m

输出描述

输出一个整数，表示爬到楼顶的方法数。

输入示例

3 2

输出示例

3

提示信息

数据范围：
1 <= m < n <= 32;

当 m = 2，n = 3 时，n = 3 这表示一共有三个台阶，m = 2 代表你每次可以爬一个台阶或者两个台阶。

此时你有三种方法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶段
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶

思路：

我们可以用动态规划来计算从第 0 阶到第 n 阶的不同爬法数。

动态规划解法思路

1. 定义状态：

   • 用 dp[i] 表示到达第 i 阶的方法数。

2. 状态转移方程：

   • 对于每一个台阶 i，它可以由前面最多 m 个台阶跳上来。因此：

   

    
   • 这里需要注意，当 i < j（j 是步长），则 dp[i-j] 不存在或为 0。

3. 初始化：

   • dp[0] = 1：到达第 0 阶的方法只有一种，就是不动。
   • dp[1] 到 dp[m] 需要根据具体情况初始化，因为从 0 阶到 m 阶的方法数各不相同。

4. 计算顺序：

   • 从 1 到 n 依次计算 dp[i]。

上代码：

#include 
#include 

using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    
    vector dp(n + 1, 0);
    dp[0] = 1; // 从第 0 阶到第 0 阶的方法数为 1
    
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            if (i >= j) {
                dp[i] += dp[i - j];
            }
        }
    }
    
    cout << dp[n] << endl;
    
    return 0;
}