算法---LeetCode 322. 零钱兑换(类背包问题)

1. 题目

原题链接

给定不同面额的硬币 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

2. 题解

2.1 解法1: 暴力dfs(超时)

   class Solution {
       int ans = Integer.MAX_VALUE;
       public int coinChange(int[] coins, int amount) {
           if (coins.length == 0) {
               return -1;
           }
           dfs(coins, 0, amount);
           // 如果没有任何一种硬币组合能组成总金额，返回 -1。
           if (ans == Integer.MAX_VALUE) {
               return -1;
           }
           return ans;
       }
       public void dfs(int[] coins, int count, int remainder) {
           if (remainder < 0) {
               return;
           }
           if (remainder == 0) {
               ans = Math.min(ans, count);
           }
           for (int i = 0; i < coins.length; i++) {
               dfs(coins, count + 1, remainder - coins[i]);
           }
       }
   }

2.2 解法2: 动态规划

1. 状态数组: dp[i] 代表凑成金额 i 所需要的最少硬币个数
2. 递推公式: 设 j为硬币可能的面值, dp[i]=min{dp[i-j]+1}
3. 初始化: dp[0]=0, 其他元素全部初始化一个大值, 为 amount+1, 所需结果为 dp[n]

    class Solution {
        public int coinChange(int[] coins, int amount) {
            if (coins.length == 0) return 0;
            int[] dp = new int[amount + 1];
            // 将dp 全部初始化为大值, 因为后面要比较取小
            Arrays.fill(dp, amount + 1);
            dp[0] = 0;
            for (int i = 1; i <= amount; i++) {
                for (int j = 0; j < coins.length; j++) {
                    // 注意这里是 >=, 需要用到 dp[0]
                    if (i - coins[j] >= 0) {
                        dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
                    }
                }
            }
            return dp[amount] == amount + 1 ? -1 : dp[amount];
        }
    }

参考: 【动态规划/背包问题】站在更高的角度看待一般性的背包问题一维空间优化

2.3 解法3: 记忆化递归

可以看出在解法 1 进行递归的时候，有很多重复的节点要进行操作，这样会浪费很多的时间。
使用数组 memo[] 来保存节点的值
memo[n] 表示钱币 n 可以被换取的最少的硬币数，不能换取就为 -1
findWay 函数的目的是为了找到 amount 数量的零钱可以兑换的最少硬币数量，返回其值 int
在进行递归的时候，memo[n]被复制了，就不用继续递归了，可以直接的调用

    class Solution {
        int[] memo;
        public int coinChange(int[] coins, int amount) {
            if(coins.length == 0){
                return -1;
            }
            memo = new int[amount];
            return findWay(coins,amount);
        }
        // memo[n] 表示钱币n可以被换取的最少的硬币数，不能换取就为-1
        // findWay函数的目的是为了找到 amount数量的零钱可以兑换的最少硬币数量，返回其值int
        public int findWay(int[] coins,int amount){
            if(amount < 0){
                return -1;
            }
            if(amount == 0){
                return 0;
            }
            // 记忆化的处理，memo[n]用赋予了值，就不用继续下面的循环
            // 直接的返回memo[n] 的最优值
            if(memo[amount-1] != 0){
                return memo[amount-1];
            }
            int min = Integer.MAX_VALUE;
            for(int i = 0;i < coins.length;i++){
                int res = findWay(coins,amount-coins[i]);
                if(res >= 0 && res < min){
                    min = res + 1; // 加1，是为了加上得到res结果的那个步骤中，兑换的一个硬币
                }
            }
            memo[amount-1] = (min == Integer.MAX_VALUE ? -1 : min);
            return memo[amount-1];
        }
    }

参考:
Java 递归、记忆化搜索、动态规划
动态规划、完全背包、BFS（包含完全背包问题公式推导）