int coinChange(int[] coins, int amount) { int[] dp = new int[amount + 1]; // 数组⼤⼩为 amount + 1，初始值也为 amount + 1 Arrays.fill(dp, amount + 1); // base case dp[0] = 0; // 外层 for 循环在遍历所有状态的所有取值 for (int i = 0; i < dp.length; i++) { // 内层 for 循环在求所有选择的最⼩值 for (int coin : coins) { // ⼦问题⽆解，跳过 if (i - coin < 0) {continue; } dp[i] = Math.min(dp[i], 1 + dp[i - coin]); } } return (dp[amount] == amount + 1) ? -1 : dp[amount]; }

这是一个使用动态规划解决硬币找零问题的代码。该算法的基本思路是：对于任意的金额数，我们都可以通过计算凑出该金额所需的最小硬币数来解决问题。具体步骤如下：

1. 创建一个长度为 amount+1 的数组 dp，初始值为 amount+1，用来存储凑出每个金额所需的最小硬币数。

2. 将 dp[0] 的值设置为 0，表示凑出金额为 0 所需的最小硬币数为 0。

3. 遍历 dp 数组，对于每个 i，遍历硬币数组 coins，如果当前硬币面值 coin 小于等于 i，那么说明可以使用该硬币凑出金额为 i，此时更新 dp[i] 的值为 dp[i-coin]+1 和 dp[i] 本身中的较小值。

4. 最终返回 dp[amount]，如果其值等于 amount+1，则说明无法凑出该金额，返回 -1。

该算法的时间复杂度为 O(amount * n)，其中 n 是硬币数组的长度。

相关问题

class Solution { public int coinChange(int[] coins, int amount) { int []dp = new int[amount+1]; //初始化为amount+1， 便于后面min比较 for(int i=1; i<amount+1; i++) { dp[i] = amount+1; } dp[0] = 0; //外层循环枚举所有可能的面值 for(int i=0; i<amount+1; i++) { //内层循环求出该面值下所有可能选择的最小值 for(int coin : coins) { //过滤掉不可能的情况 if(i<coin) { continue; } dp[i] = Math.min(dp[i], dp[i-coin]+1); } } return (dp[amount]==(amount+1)) ? (-1) : dp[amount]; }

这是一个关于硬币找零的问题，使用动态规划算法来解决。具体实现过程中，先将dp数组初始化为amount+1，然后外层循环枚举所有可能的面值，内层循环求出该面值下所有可能选择的最小值。最后返回dp[amount]，如果等于amount+1，则返回-1。

int[] memo; int coinChange(int[] coins, int amount) { memo = new int[amount + 1]; // 备忘录初始化为⼀个不会被取到的特殊值，代表还未被计算 Arrays.fill(memo, -666);return dp(coins, amount); } int dp(int[] coins, int amount) { if (amount == 0) return 0; if (amount < 0) return -1; // 查备忘录，防⽌重复计算 if (memo[amount] != -666) return memo[amount]; int res = Integer.MAX_VALUE; for (int coin : coins) { // 计算⼦问题的结果 int subProblem = dp(coins, amount - coin); // ⼦问题⽆解则跳过 if (subProblem == -1) continue; // 在⼦问题中选择最优解，然后加⼀ res = Math.min(res, subProblem + 1); } // 把计算结果存⼊备忘录 memo[amount] = (res == Integer.MAX_VALUE) ? -1 : res; return memo[amount]; }

这段代码实现的是使用动态规划算法解决零钱兑换问题。其中，memo数组是备忘录，用于记录已经计算过的子问题的结果，避免重复计算。具体实现步骤如下：

1. 初始化memo数组为一个不会被取到的特殊值，代表还未被计算。
2. 调用dp函数，传入coins数组和amount金额。
3. 如果amount为0，直接返回0；
4. 如果amount小于0，说明当前组合不可行，返回-1；
5. 查备忘录，如果memo[amount]不等于特殊值，说明已经计算过，直接返回memo[amount]。
6. 初始化res为最大值，遍历coins数组。
7. 对于每个coin，通过递归调用dp函数计算子问题的结果subProblem。
8. 如果子问题无解，则跳过当前coin，继续遍历下一个coin。
9. 在子问题中选择最优解，然后加1，更新res。
10. 将计算结果存入备忘录memo[amount]中。
11. 返回memo[amount]作为当前组合的最优解。

该算法的时间复杂度为O(amount*N)，其中N为coins数组的长度。由于使用了备忘录，避免了重复计算，因此该算法的空间复杂度为O(amount)。