1.遞迴（recursion）

def coins_changeREC(coin_values, change):
    """
    遞迴實現零錢找零
    """
    min_count = change 
    # base case
    if change in coin_values:
        return 1
    for value in [i for i in coin_values if i <= change]:
        count = 1 + coins_changeREC(coin_values, change-value)
        if
 
 count < min_count:
            min_count = count
    return min_count

2.新增caching的遞迴

def coins_changeREC_cache(coin_values, change, known_counts=None):
    """
    添加了caching的遞迴零錢找零，
    用空間換時間
    """
    if known_counts == None:
        known_counts = [0] * (change + 1) # why plus 1? think!
 

    min_count = change
    # base case
    if change in coin_values:
        return 1
    elif known_counts[change] > 0:
        return known_counts[change]
    for value in [i for i in coin_values if i <= change]:
        count = 1 + coins_changeREC_cache(coin_values,
                                          change-value,
                                          known_counts)
        if
 
 count < min_count:
            min_count = count
    known_counts[change] = min_count
    return min_count

3.動態規劃（Dynamic Programming)

def coins_changeDP(coin_values, change, min_counts=None, last_used_coins=None):
    """
    利用動態規劃(Dynamic Programming)的思想實現零錢找零
    """
    if min_counts == None:
        min_counts = [0] * (change + 1)
    if last_used_coins == None:
        last_used_coins = [0] * (change + 1)

    for cents in range(change + 1):
        min_count = cents
        for value in [i for i in coin_values if i <= cents]:
            if 1 + min_counts[cents-value] < min_count:
                min_count = 1 + min_counts[cents-value]
                last_used_coins[cents] = value
        min_counts[cents] = min_count

    return min_counts[-1], print_coins(change, last_used_coins)

def print_coins(change, last_used_coins):
    used_coins = []
    while change > 0:
        used_coins.append(str(last_used_coins[change]))
        change = change - last_used_coins[change]
    return ','.join(used_coins)

最後測試三種方法實現的零錢找零的時間效率：

def main():
    import timeit
    value_list = [1, 5, 10, 25]
    t1 = timeit.Timer('coins_changeREC(%s,%s)'%(value_list, 63),'from __main__ import coins_changeREC, main')
    t2 = timeit.Timer('coins_changeREC_cache(%s,%s)'%(value_list, 63),'from __main__ import coins_changeREC_cache, main')
    t3 = timeit.Timer('coins_changeDP(%s,%s)'%(value_list, 63),'from __main__ import coins_changeDP, main')
    print(t1.timeit(number=1))
    print(t2.timeit(number=1))
    print(t3.timeit(number=1))

main()

結果顯示：

第一種沒有新增caching的遞迴實現，完成一次63分零錢的找零竟然需要60s，簡直無法忍受。
而添加了caching的遞迴，一次找零0.22ms就完成了，這是生動的用空間換時間的演算法。而採用DP思想的演算法，0.14ms就完成了。