最少的硬币数目

描述：

给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

示例：

示例 1：

输入：coins = [1, 2, 5], amount = 11
输出：3

示例 2：

输入：coins = [2], amount = 3
输出：-1

示例 3：

输入：coins = [1], amount = 0
输出：0

示例 4：

输入：coins = [1], amount = 1
输出：1

注意：

• 这道题和前几天的青蛙跳台阶问题非常相似，硬币数组coins[]就好比青蛙一次可跳的阶数[1,2]，amount就好比青蛙要跳的目标层数，所以，在上一篇博客的基础上，我们依然采用“记录本”的方法自下而上来解决这道题目
• 自下而上遍历amount，“记录本”依次记录凑齐从1到amount的最少需要的硬币数
• 青蛙要跳到第n层，可以从第n-1层跳，也可以从n-2层开始跳。这道题目也同理，凑到amount可以从amount-coins[i]凑到，而凑到amount-coins[i]最少需要几枚硬币，这个问题我们可以去“记录本”中查找

思路1：

• “记录本”我们可以采用集合或者数组，我个人偏爱集合，因为不用关心数组越界的问题，所以最开始我是采用Map集合做的
• 在青蛙跳台阶问题中，我们确定边界为跳一层和跳两层的跳法为1和2，所以这道题目我首先设置了Map的边界：凑0元最少需要0枚硬币，凑coins[]数组中的任何值都只需要一枚硬币，以此观点来初始化Map
• 接着，我们依次从1到amount记录最优解，感觉大家应该可以看懂，我便不过多赘述

    public static int coinChangeByMap(int[] coins, int amount) {
        Map<Integer, Integer> map = new TreeMap<>();
        int best, temp;
        for (int i = 0; i < coins.length; i++) {
            map.put(coins[i], 1);
        }
        map.put(0, 0);
        for (int i = 1; i <= amount; i++) {
            //已存入最优解，跳过
            if (map.containsKey(i)) {
                continue;
            }
            //设置初始值
            best = -1;
            for (int j = 0; j < coins.length; j++) {
                //要是需要凑齐的金额连一枚硬币的面值都不够，那还凑个锤子，换下枚硬币
                //第二项判断是判断“记录本”是否有子问题的最优解
                if (i > coins[j] && map.containsKey(i - coins[j])) {
                    //子问题必须有正常解，不能是0或者-1
                    if (map.get(i - coins[j]) > 0) {
                        temp = map.get(i - coins[j]) + 1;
                        //要是第一次给best赋值就直接存入，不是第一次赋值就存入最小值
                        best = (best != -1) ? Math.min(best, temp) : temp;
                    }
                }
            }
            map.put(i, best);
        }
        return map.get(amount);
    }

思路2：

这个没什么可说的，和上一个思路一样，我只是试试看自己能不能用数组解答这道题

**注：**需要注意的是第一个for循环的判断，判断里的第二个条件是我报错以后才发现的，没加这个条件之前报数组越界（这就是为什么我不喜欢数组），调试了以后发现数组长度为amount，如果有枚硬币面值大于amount，那么在第一个for循环便会越界出错

    public static int coinChangeByArr(int[] coins, int amount) {
        int best, temp;
        int[] res = new int[amount + 1];
        res[0] = 0;
        for (int i = 0; i < coins.length && coins[i] <= amount; i++) {
            res[coins[i]] = 1;
        }
        for (int i = 1; i <= amount; i++) {
            if (res[i] > 0) {
                continue;
            }
            best = -1;
            for (int j = 0; j < coins.length; j++) {
                if (i > coins[j] && res[i - coins[j]] > 0) {
                    temp = res[i - coins[j]] + 1;
                    best = (best != -1) ? Math.min(best, temp) : temp;
                }
            }
            res[i] = best;
        }
        return res[amount];
    }

思路3：

这个是在题解里看到，真是优雅，优雅的点有以下几点：

1. 数组的初值，一枚硬币最小面值为1，所以总值为amount最多需要amount枚硬币，即最优解res[i]<=amount，amount+1一定大于最优解res[i]。之前看到有人甚至初始值赋值999或者int类型最大整数什么的，实在没必要
2. 边界原来之设置[0,0]也就是凑齐0元最少需要0枚硬币就可以了，没必要像我一样又把每枚硬币的面值和最优解1存入。因为外层的for循环i在循环到coins[]中的某个面值时，最深层的res[i-coins[j]]便会有调到记录本的res[0]=0

    public static int coinChange(int[] coins, int amount) {
        int[] res = new int[amount + 1];
        Arrays.fill(res, amount + 1);
        res[0] = 0;
        for (int i = 1; i <= amount; i++) {
            for (int j = 0; j < coins.length; j++) {
                if (i >= coins[j]) {
                    res[i] = Math.min(res[i], res[i - coins[j]] + 1);
                }
            }
        }
        return res[amount] > amount ? -1 : res[amount];
    }

收获：

• 虽然数组需要关注越界问题，我比较偏爱集合，但是数组取值快，Map的每次get都很费事，这导致了第一种做法虽然成功但却异常耗时，不如第二种做法。所以以后我决定能用数组不用集合
• Arrays工具类之前就有关注过，但还是没想起来用fill赋初值，自己写估计又要用for循环遍历赋值了，以后要再多注意一下Arrays的使用
• 动态规划感觉有些摸清思路了，大概就是找最终问题的上一步，慢慢剖析，找到底层的边界，然后对比每一步找出规律，大概就是这样，周六日再出那个动态规划的一般解法吧，平时上班996，晚上回来很累的

题目链接