参考：http://interactivepython.org/courselib/static/pythonds/index.html

1. 问题描述

Tom在自动售货机上买了一瓶饮料，售价37美分，他投入了1美元（1美元 = 100美分），现在自动售货机需要找钱给他。售货机中现在只有四种面额的硬币：1美分、5美分、10美分、25美分，每种硬币的数量充足。现在要求使用最少数量的硬币，给Tom找钱，求出这个最少数量是多少。

2. 问题分析

自动售卖机需要给Tom找零钱63美分，而售卖机中只有四种面额的硬币可以使用，现在的核心问题就是如何用四种面额的硬币来凑够63美分，并且使用的硬币数量最少。

现在我们换个角度来思考这个问题：
是不是可以将问题规模先缩小？比如我不知道凑够63美分最少需要多少个硬币，那凑够1美分、2美分的方案则显而易见是可以马上知道的。
为了后面叙述方便，用f(i) = n这个等式来表示这样一种含义：凑够i美分（0 <= i <= 63）所需要的最少硬币数量为n个，那么我们从凑够0美分开始写：

• 凑0美分：因为0美分根本不需要硬币，因此结果是0：f(0) = 0；

• 凑1美分：因为有1美分面值的硬币可以使用，所以可以先用一个1美分硬币，然后再凑够0美分即可，而f(0)的值是我们已经算出来了的，所以：f(1) = 1 + f(0) = 1 + 0 = 1，这里f(1) = 1 + f(0)中的1表示用一枚1美分的硬币；

• 凑2美分：此时四种面额的硬币中只有1美分比2美分小，所以只能先用一个1美分硬币，然后再凑够1美分即可，而f(1)的值我们也已经算出来了，所以：f(2) = 1 + f(1) = 1 + 1 = 2，这里f(2) = 1 + f(1) 中的1表示用一枚1美分的硬币；

• 凑3美分：和上一步同样的道理，f(3) = 1 + f(2) = 1 + 2 = 3；

• 凑4美分：和上一步同样的道理，f(4) = 1 + f(3) = 1 + 3 = 4；

• 凑5美分：这时就出现了不止一种选择了，因为有5美分面值的硬币。
  方案一：使用一个5美分的硬币，再凑够0美分即可，这时：f(5) = 1 + f(0) = 1 + 0 = 1，这里f(5) = 1 + f(0) 中的1表示用一枚5美分的硬币；
  方案二：使用1个1美分的硬币，然后再凑够4美分，此时：f(5) = 1 + f(4) = 1 + 4 = 5。
  综合方案一和方案二，可得：f(5) = min{1 + f(0),1 + f(4)} = 1；

• 凑6美分：此时也有两种方案可选：
  方案一：先用一个1美分，然后再凑够5美分即可，即：f(6) = 1 + f(5) = 1 + 1 = 2；
  方案二：先用一个5美分，然后再凑够1美分即可，即：f(6) = 1 + f(1) = 1 + 1 = 2。
  综合两种方案，有：f(6) = min{1 + f(5), 1 + f(1)} = 2；

• ...（省略）

从上面的分析过程可以看出，要凑够i美分，就要考虑如下各种方案的最小值：

1 + f(i - value[j])，其中value[j]表示第j种（j从0开始，0 <= j < 4）面值且value[j] <= i

那么现在就可以写出状态转移方程了：

f(i) = 0, i = 0
f(i) = 1, i = 1
f(i) = min{1 + f(i - value[j])}, i > 1，value[j] <= i

3. Talk is cheap, show the code

1. 基本版

# coding:utf-8
# 找零钱问题算法实现：基本版

# 4种硬币面值
values = [1,5,10,25]

# 凑够amount这么多钱数需要的最少硬币个数
def minCoins(amount):
    # 需要的最少硬币个数
    ret_min = amount
    
    if amount < 1:
        ret_min = 0
    # 如果要找的钱数恰好是某种硬币的面值，那么最少只需一个硬币
    elif amount in values:
        ret_min = 1
    else:
        # 遍历面值数组中面值小于等于amount的那些元素
        for v in [x for x in values if x <= amount]:
            # 用面值为v的硬币+其他硬币找零所需的最少硬币数
            min_num = 1 + minCoins(amount - v)
            # 判断min_num和ret_min的大小，更新ret_min
            if min_num < ret_min:
                ret_min = min_num
                
    return ret_min

def main():
    print minCoins(63)
    
main()  

将上面脚本保存成coins.py文件，在ipython中执行：%time %run coins.py，得到的结果如下：

6

CPU times: user 1min 45s, sys: 0 ns, total: 1min 45s

Wall time: 1min 45s

分析：可以看出，在我的电脑上，仅仅是为了计算用4种面额找63美分零钱，就耗时1分钟45秒（105秒），这是无法忍受的。那么究竟为什么耗时这么巨大？下面对代码稍加改造进行一下性能分析。

2. 性能分析

# coding:utf-8
# 找零钱问题算法实现：基本版性能分析

# 统计递归次数
recursion_num = 0

# 4种硬币面值
values = [1,5,10,25]

# 凑够amount这么多钱数需要的最少硬币个数
def minCoins(amount):
    global recursion_num
    
    # 需要的最少硬币个数
    ret_min = amount
    
    if amount < 1:
        ret_min = 0
    # 如果要找的钱数恰好是某种硬币的面值，那么最少只需一个硬币
    elif amount in values:
        ret_min = 1
    else:
        # 遍历面值数组中面值小于等于amount的那些元素
        for v in [x for x in values if x <= amount]:
            # 用面值为v的硬币+其他硬币找零所需的最少硬币数
            min_num = 1 + minCoins(amount - v)
            # 判断min_num和ret_min的大小，更新ret_min
            if min_num < ret_min:
                ret_min = min_num
    
    recursion_num += 1
    return ret_min

def main():
    print minCoins(63)
    print recursion_num
    
main()  

将上面脚本保存成coins.py文件，在ipython中执行：%time %run coins.py，得到的结果如下：

6

67716925

CPU times: user 2min, sys: 36 ms, total: 2min

Wall time: 2min

分析：可见，minCoins函数一共被递归调用了67716925次，真是难以想象，为了计算最多64个函数值（amount取0~63），居然递归调用了函数minCoins67716925次，平均求每个值调用了1058076次。那么问题出在哪里了呢？出在了重复计算上，有很多值被重复计算了上百万次。那么如何尽量减少重复计算呢？下面用一个缓存数组来缓存每次求出的函数值，供后面使用，从而减少重复计算。

3. 性能优化版

# coding:utf-8
# 找零钱问题算法实现：基本版性能分析

# 统计递归次数
recursion_num = 0

# 4种硬币面值
values = [1,5,10,25]

# 缓存数组，为一个一维数组，用于缓存每次递归函数求得的值
# cache[i]表示凑够i美分所需的最少硬币个数，cache的元素都被初始化为-1，表示个数未知
cache = []

# 初始化缓存数组
def init(amount):
    global cache
    cache = [-1] * (amount + 1)

# 凑够amount这么多钱数需要的最少硬币个数
def minCoins(amount):
    global recursion_num
    global cache
    
    # 需要的最少硬币个数
    ret_min = amount
    
    # 如果缓存数组中有对应的值，那么直接从中取，不再重复计算了
    if cache[amount] != -1:
        ret_min = cache[amount]
    elif amount < 1:
        ret_min = 0
    # 如果要找的钱数恰好是某种硬币的面值，那么最少只需一个硬币
    elif amount in values:
        ret_min = 1
    else:
        # 遍历面值数组中面值小于等于amount的那些元素
        for v in [x for x in values if x <= amount]:
            # 用面值为v的硬币+其他硬币找零所需的最少硬币数
            min_num = 1 + minCoins(amount - v)
            # 判断min_num和ret_min的大小，更新ret_min
            if min_num < ret_min:
                ret_min = min_num
    
    # 更新缓存数组
    cache[amount] = ret_min
    
    recursion_num += 1
    return ret_min

def main():
    init(63)
    print minCoins(63)
    print cache
    print recursion_num
    
main()  

将上面脚本保存成coins.py文件，在ipython中执行：%time %run coins.py，得到的结果如下：

6

[-1, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 3, 4, 5, 6, 7, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 3, 4, 5, 6]

206

CPU times: user 4 ms, sys: 0 ns, total: 4 ms

Wall time: 2.2 ms

分析：可见，cache数组除了cache[0]没被用到以外，其他元素都被利用到了，利用率还是很高的。使用缓存数组后，minCoins函数的递归调用次数从67716925次降低到了206次，降低了328722倍；程序耗时从105秒降低到了2.2ms，降低了47727倍，优化效果是巨大的。

上一篇：动态规划系列（1）——金矿模型的理解中也使用到了缓存数组，优化效果也是巨大的，在本文中又一次看到了动态规划中缓存数组的重要性。