零钱

柠檬水找零

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。

顾客排队购买你的产品，(按账单 bills 支付的顺序)一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。

如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

示例 1：

输入：[5,5,5,10,20]输出：true解释： 前 3 位顾客那里，我们按顺序收取 3 张 5 美元的钞票。
第 4 位顾客那里，我们收取一张 10 美元的钞票，并返还 5 美元。
第 5 位顾客那里，我们找还一张 10 美元的钞票和一张 5 美元的钞票。
由于所有客户都得到了正确的找零，所以我们输出 true。

示例 2：

输入：[5,5,10]输出：true

示例 3：

输入：[10,10]输出：false

示例 4：

输入：[5,5,10,10,20]输出：false解释：
前 2 位顾客那里，我们按顺序收取 2 张 5 美元的钞票。
对于接下来的 2 位顾客，我们收取一张 10 美元的钞票，然后返还 5 美元。
对于最后一位顾客，我们无法退回 15 美元，因为我们现在只有两张 10 美元的钞票。
由于不是每位顾客都得到了正确的找零，所以答案是 false

模拟购买过程即可
用两个变量记录拥有的5和10的个数

• 如果给的是5，count5++，不用找零
• 如果给的是10，count10++，找一个5，count5--
• 如果给的是20，两种找零方式：找一个10,、一个5，找3个5

public boolean lemonadeChange(int[] bills) {
    int count5 = 0;
    int count10 = 0;
    for (int bill : bills) {
        if (bill == 5) {
            count5++;
        } else if (bill == 10){
            count10++;
            if (count5 > 0) {
                count5--;
            } else {
                return false;
            }
        } else {
            if (count10 > 0 && count5 > 0){
                count10--;
                count5--;
            } else if (count5 >= 3){
                count5 -= 3;
            } else {
                return false;
            }
        }
    }
    return true;
}

零钱兑换

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

示例 1:

输入: coins = [1, 2, 5], amount = 11输出: 3解释: 11 = 5 + 5 + 1

示例 2:

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

说明:
你可以认为每种硬币的数量是无限的

方法一：搜索回溯(超时)
计算剩余amout找零数量

private int minCount = Integer.MAX_VALUE;

public int coinChange(int[] coins, int amount) {
    finWay(coins, amount, 0);
    return minCount == Integer.MAX_VALUE ? -1 : minCount;
}

public void finWay(int[] coins, int amount, int depth) {
    if (amount == 0) {
        minCount = Math.min(minCount, depth);
        return;
    }
    if (amount < 0) {
        return;
    }
    for (int coin : coins) {
        finWay(coins, amount - coin, depth + 1);
    }
}

或者

public int coinChange(int[] coins, int amount) {
    int minCount = finWay(coins, amount);
    return minCount == Integer.MAX_VALUE ? -1 : minCount;
}

public int finWay(int[] coins, int amount) {
    if (amount == 0) {
        return 0;
    }
    if (amount < 0) {
        return Integer.MAX_VALUE;
    }
    int count = Integer.MAX_VALUE - 1;
    for (int coin : coins) {
        count = Math.min(count, finWay(coins, amount - coin));
    }
    return count + 1;
}

时间复杂度O(Sⁿ)，S为总金额

方法二：记忆优化

public int coinChange(int[] coins, int amount) {
    int[] dp = new int[amount + 1];
    int minCount = finWay(coins, amount, dp);
    return minCount == Integer.MAX_VALUE ? -1 : minCount;
}

public int finWay(int[] coins, int amount, int[] dp) {
    if (amount == 0) {
        return 0;
    }
    if (amount < 0) {
        return Integer.MAX_VALUE;
    }
    if (dp[amount] != 0) {
        return dp[amount];
    }
    int count = Integer.MAX_VALUE - 1;
    for (int coin : coins) {
        count = Math.min(count, finWay(coins, amount - coin, dp));
    }
    dp[amount] = count + 1;
    return dp[amount];
}

时间复杂度O(Sn)，共需要计算 S 个状态的答案，而计算一个状态的答案需要枚举 n个面额值

方法三：动态规划

public int coinChange(int[] coins, int amount) {
    int[] dp = new int[amount + 1];
    for (int i = 1; i <= amount ; i++) {
        int min = Integer.MAX_VALUE;
        for (int coin : coins) {
            if (i - coin >= 0 && dp[i - coin] < min) {
                min = dp[i - coin] + 1;
            }
        }
        dp[i] = min;
    }
    return dp[amount] == Integer.MAX_VALUE ? -1 : dp[amount];
}

时间复杂度O(Sn)

方法四：贪心+dfs
想要总硬币数最少，肯定是优先用大面值硬币，所以对 coins 按从大到小排序
先丢大硬币，再丢会超过总额时，就可以递归下一层丢的是稍小面值的硬币

注意：最先找到的并不是最优解
如 [1,7,10] 14 这种用例，按照贪心思路 10 + 1 + 1 + 1 + 1 会比 7 + 7 更早找到
所以还是需要把所有情况都递归完

private int minCount = Integer.MAX_VALUE;

public int coinChange(int[] coins, int amount) {
    Arrays.sort(coins);
    dfs(coins, coins.length - 1, amount, 0);
    return minCount == Integer.MAX_VALUE ? -1 : minCount;
}

public void dfs(int[] coins, int i, int amount, int usedCount) {
    int count = amount / coins[i];
    for (int j = count; j >= 0; j--) {
        int temp = amount - j * coins[i];
        if (temp == 0) {
            minCount = Math.min(minCount, usedCount + j);
            return;
        }
        if (temp < 0 || usedCount + j >= minCount || i <= 0) {
            return;
        }
        dfs(coins, i - 1, temp, usedCount + j);
    }
}

零钱兑换 II

给定不同面额的硬币和一个总金额。写出函数来计算可以凑成总金额的硬币组合数。假设每一种面额的硬币有无限个。

示例 1:

输入: amount = 5, coins = [1, 2, 5]输出: 4解释: 有四种方式可以凑成总金额:
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1

示例 2:

输入: amount = 3, coins = [2]输出: 0解释: 只用面额2的硬币不能凑成总金额3。

示例 3:

输入: amount = 10, coins = [10]输出: 1

注意:
你可以假设：

• 0 <= amount (总金额) <= 5000
• 1 <= coin (硬币面额) <= 5000
• 硬币种类不超过 500 种
• 结果符合 32 位符号整数

动态规划

下面的解法错误，因为求的是排列数，所以结果会更大，而需要的是组合数

public int change(int amount, int[] coins) {
    int[] dp = new int[amount + 1];
    dp[0] = 1;
    for (int i = 1; i <= amount; i++) {
        for (int j = 0; j < coins.length; j++) {
            if (i - coins[j] >= 0) {
                dp[i] += dp[i - coins[j]];
            }
        }
    }
    return dp[amount];
}

正确解法：

public int change(int amount, int[] coins) {
    int[] dp = new int[amount + 1];
    dp[0] = 1;
    for (int i = 0; i < coins.length; i++) {
        for (int j = coins[i]; j <= amount; j++) {
            dp[j] += dp[j - coins[i]];
        }
    }
    return dp[amount];
}