refer: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），居然递归调用了函数minCoins 67716925次，平均求每个值调用了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倍，优化效果是巨大的。
上一篇动态规划之金矿模型中也使用到了缓存数组，优化效果也是巨大的，在本文中又一次看到了动态规划中缓存数组的重要性。