518. 零钱兑换 II

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

题解：这道题就是选择任意钱数构成的方法数，一般什么方法数都可以暴力递归解决。就是每一张金额不一样的可以选0-n张，在这里，n*钱的面值肯定是要小于等于剩余的钱的，不把这个想明白会一直递归下去。然后递归结束条件要理明白，越界了或者刚好凑成了0，这个时候就是递归条件。一开始写递归时边界条件未考虑明白，导致一直报错。

class Solution {
    public static int change(int amount, int[] coins) {
		return process(amount, coins,0);

	}

	public static int process(int account, int[] coins, int position) {
		if (account == 0)
			return 1;

		if (account < 0 || position >= coins.length)
			return 0;

		int sum = 0;
			for (int zhang = 0; account >= zhang * coins[position]; zhang++) 
				sum += process(account - zhang * coins[position], coins,position+1);

		return sum;
	}
}

在这个时候，其实递归结束条件是有问题的，不过报的是超时。

然后添加了一个缓存，还是超时。

class Solution {
    public static int change(int amount, int[] coins) {
		int dp[][] = new int[amount + 1][coins.length + 1];
		return process(amount, coins, 0, dp);

	}

	public static int process(int account, int[] coins, int position, int dp[][]) {
		if(dp[account][position]!=0) {
			return dp[account][position];
		}
		if (account == 0) {
			dp[account][position]=1;
			return dp[account][position];
		}

		if (account < 0 || position >= coins.length)
			return 0;

		int sum = 0;
		for (int zhang = 0; account >= zhang * coins[position]; zhang++) {
			sum += process(account - zhang * coins[position], coins, position + 1,dp);
		}
		dp[account][position] = sum;
		return dp[account][position];
	}
}

当用动态规划时，发现了错误，递归的边界条件边界有问题，并不是account为0，就是一种方法数。因为此时position还可能没有列举完全，导致列举的数量不足。修改边界条件，当且只要position到达数组尾，并且account刚好为0，才是一种方法数。

class Solution {
   public static int change(int amount, int[] coins) {
		int dp[][] = new int[amount + 1][coins.length + 1];
		dp[0][coins.length] = 1;
	
//
		for (int a = 0; a < amount + 1; a++) {
			for (int p = coins.length-1; p >= 0; p--) {
				for (int zhang = 0; a >= zhang * coins[p]; zhang++) {
					dp[a][p] += dp[a - zhang * coins[p]][p + 1];
				}
			}
		}
		//System.out.println(Arrays.deepToString(dp));
		return dp[amount][0];

	}
}

在上一篇博客提到，其实最后的枚举累加是没有必要的，我们可以让前一个数代替枚举累加。

class Solution {
   public static int change(int amount, int[] coins) {
		int dp[][] = new int[amount + 1][coins.length + 1];
		dp[0][coins.length] = 1;
	
//
		for (int a = 0; a < amount + 1; a++) {
			for (int p = coins.length-1; p >= 0; p--) {
                // dp[a][p] = 
                dp[a][p] = dp[a][p+1];
                if(a>=coins[p])
					dp[a][p] += dp[a - coins[p]][p];
			}
		}
		//System.out.println(Arrays.deepToString(dp));
		return dp[amount][0];

	}
}