python 最小硬币数_为什么这个递归回溯函数比用于计算python中最小硬币数量的非递归函数慢？...

我有这个代码来计算硬币的最小数量来进行更改.一个是非递归版本,由函数更改调用,recursive-backtrack函数调用get_min_coin_configuration.在后一个函数中,我缓存了之前计算过的结果.我认为应该加快这个过程.但实际上,它比不缓存结果的非递归的慢得多.任何线索为什么这个慢？

这是整个代码

cat minimumcoinrecurse.py

import timeit

def change(amount):

money = ()

for coin in [25,10,5,1]:

num = amount/coin

money += (coin,) * num

amount -= coin * num

return money

#print change(63)

def get_min_coin_configuration(sum=None, coins=None, cache=None):

if cache == None: # this is quite crucial if its in the definition its presistent ...

cache = {}

if sum in cache:

return cache[sum]

elif sum in coins: # if sum in coins, nothing to do but return.

cache[sum] = [sum]

#print cache

return cache[sum]

elif min(coins) > sum: # if the largest coin is greater then the sum, there's nothing we can do.

cache[sum] = []

return cache[sum]

else: # check for each coin, keep track of the minimun configuration, then return it.

min_length = 0

min_configuration = []

for coin in coins:

results = get_min_coin_configuration(sum - coin, coins, cache)

if results != []:

if min_length == 0 or (1 + len(results)) < len(min_configuration):

#print "min config", min_configuration

min_configuration = [coin] + results

#print "min config", min_configuration

min_length = len(min_configuration)

cache[sum] = min_configuration

#print "second print", cache

return cache[sum]

def main():

print "recursive method"

print "time taken",

t=timeit.Timer('get_min_coin_configuration(63,[25,10,5,1])',"from __main__ import get_min_coin_configuration")

print min(t.repeat(3,100))

print get_min_coin_configuration(63,[25,10,5,1])

print '*'*45

print "non-recursive"

print "time taken",

t1=timeit.Timer('change(63)',"from __main__ import change")

print min(t1.repeat(3,100))

print change(63)

if __name__ == "__main__":

main()

输出：

recursive method

time taken 0.038094997406

[25, 25, 10, 1, 1, 1]

*********************************************

non-recursive

time taken 0.000286102294922

(25, 25, 10, 1, 1, 1)