零钱兑换问题

零钱兑换

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] <= 231 - 1
• 0 <= amount <= 104

方法一：暴力递归（会超时）

class Solution {
    public int coinChange(int[] coins, int amount) {
        if(amount == 0){
            return 0;
        }
        for (int i = 0; i < coins.length-1; i++) {
           for (int i1 = i+1; i1 < coins.length; i1++) {
               if(coins[i1] > coins[i]){
                   int a = coins[i1];
                   coins[i1] = coins[i];
                   coins[i] = a;
               }
           }
       }
       return dps(coins,amount,0,0);
    }
    public int dps(int[] coins,int amount,int index,int count){
        if(amount == 0){
            return count;
        }else if(amount < 0){
            return -1;
        }else{
            int result = -1;
            for(int i = index ; i<coins.length;i++){
                count++;
                int a = dps(coins,amount-coins[i],i,count);
                count--;
                if(a > 0){ 
                    result = result>0 ? Integer.min(a,result):a;
                }

            }
            return result;
        }
    }
}

方法二：动态规划

class Solution {
    public int coinChange(int[] coins, int amount) {
        int[] list = new int[amount + 1];
        Arrays.sort(coins);
        list[0] = 0;
        for(int i = 1;i<amount+1;i++){
            if(i % coins[0] != 0){
                list[i] = -1;
            }else{
                list[i] = i / coins[0];
            }
        }
        for(int i = 1;i<coins.length ;i++){
            int a = coins[i];
            for(int j = 1;j<amount+1;j++){
                if(a > j){
                    continue;
                }
                if(list[j-a] != -1){
                    if(list[j] == -1){
                        list[j] = list[j-a] + 1;
                    }else {
                        list[j] = Integer.min(list[j],list[j-a] + 1);
                    }
                } else if (j % a == 0) {
                    list[j] = j / a;
                }
            }
        }
        return list[amount];
    }

}

leetcode 518

题目描述

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

假设每一种面额的硬币有无限个。

题目数据保证结果符合 32 位带符号整数。

示例 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

提示：

• 1 <= coins.length <= 300
• 1 <= coins[i] <= 5000
• coins 中的所有值 互不相同
• 0 <= amount <= 5000

方法一：暴力递归（会超时）

class Solution {
    public int change(int amount, int[] coins) {
        for (int i = 0; i < coins.length-1; i++) {
            for (int i1 = i+1; i1 < coins.length; i1++) {
                if(coins[i1] > coins[i]){
                    int a = coins[i1];
                    coins[i1] = coins[i];
                    coins[i] = a;
                }
            }
        }
        return dps(amount,coins,0);
    }
    public int dps(int amount,int[] coins,int index){
        if(amount == 0){
            return 1;
        }else if(amount < 0){
            return 0;
        }else{
            int count = 0;
            for(int i = index; i< coins.length;i++){
                count += dps(amount - coins[i],coins,i);
            }
            return count;
        }
    }
}

方法二：动态规划

class Solution {
    public int change(int amount, int[] coins) {
        int[] list = new int[amount+1];
        Arrays.sort(coins);
        list[0] = 1;
        for(int i = 1 ; i < amount + 1 ; i++){
            if(i % coins[0] != 0){
                list[i] = 0;
            }else{
                list[i] = 1;
            }
        }
        for(int i = 1 ; i < coins.length ; i++){
            int a = coins[i];
            for(int j = i ; j < amount + 1 ; j++){
                if(a > j){
                    continue;
                }
                if(a == j){
                    list[j] += 1;
                    continue;
                }
                list[j] = Math.max(list[j],list[j-a] + list[j]);
            }
        }
        return list[amount];
    }
}