文章目录
题目链接
题目描述
给你一个整数数组 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
问题分析
零钱兑换
问题特征
完全背包问题
求最优解
硬币可重复使用
解决思路
动态规划
自底向上
状态转移
贪心算法
不适用
反例存在
BFS搜索
层序遍历
找最短路径
关键点
状态定义
转移方程
初始化
边界处理
这是一个经典的完全背包问题，核心在于：
- 每种硬币可以使用无限次
- 需要找到凑成目标金额的最少硬币数
- 如果无法凑成，返回 -1
解法一：动态规划（自底向上）
算法原理
动态规划是解决此问题的最优方法。我们定义状态 dp[i] 表示凑成金额 i 所需的最少硬币数。
状态转移方程：
dp[i] = min(dp[i], dp[i - coin] + 1)其中 coin 是硬币面额，i - coin >= 0。
思路流程：
是
否
否
是
否
是
是
否
开始
初始化 dp 数组
dp0 = 0, 其余为无穷大
遍历金额 i = 1 到 amount
遍历每个硬币 coin
i >= coin?
更新 dp[i] = min(dp[i], dp[i-coin]+1)
所有硬币遍历完?
所有金额遍历完?
dp[amount] == 无穷大?
返回 -1
返回 dp[amount]
结束
Java 实现
java
class Solution {
public int coinChange(int[] coins, int amount) {
// dp[i] 表示凑成金额 i 所需的最少硬币数
int[] dp = new int[amount + 1];
// 初始化：除了 dp[0] = 0，其余都设为一个不可能的大值
Arrays.fill(dp, amount + 1);
dp[0] = 0;
// 遍历每个金额
for (int i = 1; i <= amount; i++) {
// 尝试每种硬币
for (int coin : coins) {
// 如果当前硬币面额不大于当前金额
if (coin <= i) {
// 状态转移：选择使用当前硬币或不使用
dp[i] = Math.min(dp[i], dp[i - coin] + 1);
}
}
}
// 如果 dp[amount] 仍然是初始值，说明无法凑成
return dp[amount] > amount ? -1 : dp[amount];
}
}复杂度分析
- 时间复杂度： O(amount × n)，其中 n 是硬币种类数。需要计算 amount 个状态，每个状态需要遍历所有硬币。
- 空间复杂度： O(amount)，需要一个长度为 amount + 1 的 dp 数组。
示例演示
以 coins = [1, 2, 5], amount = 11 为例：
| 金额 i | dp[i] | 计算过程 |
|---|---|---|
| 0 | 0 | 初始值 |
| 1 | 1 | min(∞, dp[0]+1) = 1 |
| 2 | 1 | min(∞, dp[1]+1, dp[0]+1) = 1 |
| 3 | 2 | min(∞, dp[2]+1, dp[1]+1) = 2 |
| 4 | 2 | min(∞, dp[3]+1, dp[2]+1) = 2 |
| 5 | 1 | min(∞, dp[4]+1, dp[3]+1, dp[0]+1) = 1 |
| ... | ... | ... |
| 11 | 3 | dp[10]+1 或 dp[6]+1 = 3 |
解法二：动态规划（记忆化搜索）
算法原理
记忆化搜索是自顶向下的动态规划方法，通过递归实现，并使用备忘录避免重复计算。
递归思路：
- 对于金额
amount，尝试使用每种硬币 - 递归计算
amount - coin的最少硬币数 - 取所有可能中的最小值
coinChange 11
尝试硬币1
尝试硬币2
尝试硬币5
coinChange 10
coinChange 9
coinChange 6
coinChange 5
coinChange 4
coinChange 1
Java 实现
java
class Solution {
private int[] memo;
public int coinChange(int[] coins, int amount) {
memo = new int[amount + 1];
Arrays.fill(memo, -2); // -2 表示未计算，-1 表示无解
return dfs(coins, amount);
}
private int dfs(int[] coins, int amount) {
// 基础情况
if (amount == 0) return 0;
if (amount < 0) return -1;
// 如果已经计算过，直接返回
if (memo[amount] != -2) {
return memo[amount];
}
int minCoins = Integer.MAX_VALUE;
// 尝试每种硬币
for (int coin : coins) {
int subResult = dfs(coins, amount - coin);
// 如果子问题有解
if (subResult >= 0) {
minCoins = Math.min(minCoins, subResult + 1);
}
}
// 记录结果
memo[amount] = (minCoins == Integer.MAX_VALUE) ? -1 : minCoins;
return memo[amount];
}
}复杂度分析
- 时间复杂度： O(amount × n)，每个状态只计算一次，每次需要遍历所有硬币。
- 空间复杂度： O(amount)，需要备忘录数组和递归调用栈空间。
解法三：BFS 广度优先搜索
算法原理
将问题看作图的最短路径问题：
- 起点是金额 0
- 终点是目标金额 amount
- 每次可以选择一种硬币，相当于图中的一条边
- 求从起点到终点的最短路径
+1
+2
+5
+1
+2
+5
+1
+2
+5
0
1
2
5
2
3
6
3
4
7
Java 实现
java
class Solution {
public int coinChange(int[] coins, int amount) {
if (amount == 0) return 0;
Queue<Integer> queue = new LinkedList<>();
boolean[] visited = new boolean[amount + 1];
queue.offer(0);
visited[0] = true;
int step = 0;
while (!queue.isEmpty()) {
int size = queue.size();
step++;
// 处理当前层的所有节点
for (int i = 0; i < size; i++) {
int current = queue.poll();
// 尝试每种硬币
for (int coin : coins) {
int next = current + coin;
// 找到目标金额
if (next == amount) {
return step;
}
// 如果未访问且未超过目标金额
if (next < amount && !visited[next]) {
visited[next] = true;
queue.offer(next);
}
}
}
}
return -1;
}
}复杂度分析
- 时间复杂度： O(amount × n)，最坏情况下需要访问所有金额状态。
- 空间复杂度： O(amount)，需要队列和访问标记数组。
解法对比分析
| 解法 | 时间复杂度 | 空间复杂度 | 实现难度 | 性能表现 | 适用场景 |
|---|---|---|---|---|---|
| 动态规划（自底向上） | O(amount × n) | O(amount) | ⭐⭐⭐ | 最优 | 通用场景，推荐使用 |
| 动态规划（记忆化搜索） | O(amount × n) | O(amount) | ⭐⭐⭐⭐ | 良好 | 递归思维更直观 |
| BFS 广度优先搜索 | O(amount × n) | O(amount) | ⭐⭐⭐⭐ | 良好 | 理解最短路径问题 |
性能对比说明
-
动态规划（自底向上） 是最推荐的解法：
- 代码简洁清晰
- 无递归开销
- 空间利用率高
- 适合大规模数据
-
记忆化搜索 适合递归思维：
- 代码逻辑更直观
- 有递归调用栈开销
- 适合理解问题本质
-
BFS 搜索 提供不同视角：
- 将问题转化为图论
- 层序遍历保证最优解
- 队列操作有额外开销
- 适合理解最短路径思想
零钱兑换问题是完全背包问题的经典应用，核心在于理解状态转移方程。动态规划自底向上的方法是最优解，时间和空间复杂度都达到了理论最优。掌握这道题的解法，对理解动态规划和完全背包问题有重要意义。