换零钱的三种解法（Leetcode518解析）

CoinChange 2是动态规划的经典题目，对递归（会超时）改写为动态规划的技巧要求较高。
题意：You are given coins of different denominations and a total amount of money. Write a function to compute the number of combinations that make up that amount. You may assume that you have infinite number of each kind of coin.
输入输出：
Input: amount = 5, coins = [1, 2, 5]
Output: 4
Explanation: there are four ways to make up the amount:
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1

Input: amount = 3, coins = [2]
Output: 0
Explanation: the amount of 3 cannot be made up just with coins of 2.

解答：首先我们能想到的一个直观思路是递归，可以抽象出这样的一个子问题：在银币数组中，从首位置0出发，到当前位置i这些银币，能凑齐当前目标钱数目j的方法数，记为res[i][j].
递推关系如下： while coins[i] * k <= j
res[i][j] += res[i+1][j-k*coins[i]]; 当前位置的银币选用k个。
边界条件：res[i][0] = 1; res[coins.length][j]=0 (j!=0时)
由此思路写出递归的代码，但是这个提交上去会超时。

	public static int coins1(int[] arr, int aim) {
		if (arr == null || arr.length == 0 || aim < 0) {
			return 0;
		}
		return process1(arr, 0, aim);
	}

	public static int process1(int[] arr, int index, int aim) {
		int res = 0;
		if (index == arr.length) {
			res = aim == 0 ? 1 : 0;
		} else {
			for (int i = 0; arr[index] * i <= aim; i++) {
				res += process1(arr, index + 1, aim - arr[index] * i);
			}
		}
		return res;
	}

改写为动态规划，可以accepted。

 public int change(int aim, int[] arr) {
        if(aim==0)   return 1;
       if (arr == null || arr.length == 0 || aim < 0) {
            return 0;
        }
        
        int[][] dp = new int[arr.length][aim + 1];
        for (int i = 0; i < arr.length; i++) {
            dp[i][0] = 1;
        }
        for (int j = 1; arr[0] * j <= aim; j++) {
            dp[0][arr[0] * j] = 1;
        }
        int num = 0;
        for (int i = 1; i < arr.length; i++) {
            for (int j = 1; j <= aim; j++) {
                num = 0;
                for (int k = 0; j - arr[i] * k >= 0; k++) {
                    num += dp[i - 1][j - arr[i] * k];
                }
                dp[i][j] = num;
            }
        }
        return dp[arr.length - 1][aim];
    }

以上答案耗时较多，只击败了百分之10的人，对时间空间进行优化，得到如下优质代码（时间缩短+空间压缩），击败了百分之60的人，空间占用率最低。

public int change(int aim, int[] arr) {
        if(aim==0)   return 1;
      if (arr == null || arr.length == 0 || aim < 0) {
			return 0;
		}
		int[] dp = new int[aim + 1];
		for (int j = 0; arr[0] * j <= aim; j++) {
			dp[arr[0] * j] = 1;
		}
		for (int i = 1; i < arr.length; i++) {
			for (int j = 1; j <= aim; j++) {
				dp[j] += j - arr[i] >= 0 ? dp[j - arr[i]] : 0;
			}
		}
		return dp[aim];
    }