LeetCode Hot100（70/100）—— 322. 零钱兑换

题目链接

LeetCode 322. 零钱兑换

题目描述

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

问题分析

这是一个经典的完全背包问题，核心在于：

• 每种硬币可以使用无限次
• 需要找到凑成目标金额的最少硬币数
• 如果无法凑成，返回 -1

解法一：动态规划（自底向上）

算法原理

动态规划是解决此问题的最优方法。我们定义状态 dp[i] 表示凑成金额 i 所需的最少硬币数。

状态转移方程：

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

其中 coin 是硬币面额，i - coin >= 0。

思路流程：

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 的最少硬币数
• 取所有可能中的最小值

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
• 每次可以选择一种硬币，相当于图中的一条边
• 求从起点到终点的最短路径

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)	⭐⭐⭐⭐	良好	理解最短路径问题

性能对比说明

1. 动态规划（自底向上） 是最推荐的解法：

   • 代码简洁清晰
   • 无递归开销
   • 空间利用率高
   • 适合大规模数据

2. 记忆化搜索 适合递归思维：

   • 代码逻辑更直观
   • 有递归调用栈开销
   • 适合理解问题本质

3. BFS 搜索 提供不同视角：

   • 将问题转化为图论
   • 层序遍历保证最优解
   • 队列操作有额外开销
   • 适合理解最短路径思想

---

零钱兑换问题是完全背包问题的经典应用，核心在于理解状态转移方程。动态规划自底向上的方法是最优解，时间和空间复杂度都达到了理论最优。掌握这道题的解法，对理解动态规划和完全背包问题有重要意义。