递归与动态规划---换钱的最少货币数（每种货币有无数张）

【题目】

　　给定一个数组arr，arr中所有的值都为正数且不重复，每个值代表一种面值的货币，每种面值的货币有无数张，再给定一个整数aim代表要找的钱数，求组成aim的最少货币数。

【基本思路】

　　生成行数为N、列数为aim+1的dp矩阵，dp[i][j]的含义是在可以任意使用arr[0…i]货币的情况下，组成j所需的最小张数，矩阵的每一行和每一列可以先确定，其他的位置dp[i][j] = min(dp[i-1][j], dp[i][j-arr[i]]+1)，接下来解释dp[i][j]的值怎么确定：　　

1. 矩阵的第一行表示只使用货币arr[0]的情况下，可以组成的钱数，当然只有钱数等于arr[0]的倍数时才成立，所以把这些位置设置为j//arr[0]，其余部分设置为32位整数的最大值（为什么是32位整数的最大值？ 因为题目求的是换钱的最少货币数，所以找不开的情况下要设置的尽可能大）

2. 矩阵的第一列表示找的钱数为0的情况下需要的最小张数，货币为0是完全不需要任何货币，所以全部设置为0。

3. 矩阵的其他位置来自以下的情况：
   1）完全不使用货币arr[i]的情况下的最小张数，即dp[i-1][j]。
   2）只使用1张货币arr[i]的情况下的最小张数，即dp[i-1][j-arr[i]]+1。
   3）只使用2张货币arr[i]的情况下的最小张数，即dp[i-1][j-2*arr[i]]+2。
   ……
   k+1）只使用k张货币arr[i]的情况下的最小张数，即dp[i-1][j-k*arr[i]]+k。k = j//arr[i]
   选择其中的最小值即可。

   根据以上的推理，我们可以推导出使用arr[0…i]来组成j-arr[i]情况下的最少货币数，即dp[i][j-arr[i]]，即将j-arr[i]整体看作j，分别为:
   1）dp[i-1][j-arr[i]]。
   2）dp[i-1][j-2*arr[i]]+1。
   3）dp[i-1][j-3*arr[i]]+2。
   ……
   k+1）dp[i-1][j-(k+1)*arr[i]]+k。k = j - arr[i]//arr[i]
   我们发现这些值都为dp[i][j]除第1项以外相应情况下+1。所以，我们可以推到出dp[i][j]的公式为dp[i][j] = min(dp[i-1][j], dp[i][j-arr[i]] + 1)。

   下面是使用python3.5实现的代码

#python3.5
#经典动态规划实现
def minCoins1(arr, aim):
    if arr == None or len(arr) == 0 or aim < 0:
        return -1
    row = len(arr)
    dp = [[sys.maxsize for i in range(aim+1)] for j in range(row)]
    for i in range(row):
        dp[i][0] = 0
    for j in range(1, aim+1):
        if j % arr[0] == 0:
            dp[0][j] = j // arr[0]
    for i in range(1, row):
        for j in range(1, aim+1):
            left = sys.maxsize
            if j - arr[i] >= 0 and dp[i][j-arr[i]] != sys.maxsize:
                left = dp[i][j-arr[i]] + 1
            dp[i][j] = min(left, dp[i-1][j])
    return dp[row-1][aim] if dp[row-1][aim] != sys.maxsize else -1

#经过空间压缩的动态规划
def minCoins2(arr, aim):
    if arr == None or len(arr) == 0 or aim < 0:
        return -1
    row = len(arr)
    dp = [sys.maxsize for i in range(aim+1)]
    dp[0] = 0
    for i in range(1, aim+1):
        if i % arr[0] == 0:
            dp[i] = i // arr[0]
    for i in range(1, row):
        dp[0] = 0
        for j in range(1, aim+1):
            left = sys.maxsize
            if j - arr[i] >= 0 and dp[j-arr[i]] != sys.maxsize:
                left = dp[j-arr[i]] + 1
            dp[j] = min(left, dp[j])
    return dp[aim] if dp[aim] != sys.maxsize else -1