递归地在python中实现’最小硬币数’
作者：互联网
此问题与here中提出的问题相同.
给出一个硬币列表,它们的值(c1,c2,c3,… cj,…)和总和i.找到总和为i的最小硬币数量(我们可以使用我们想要的一种类型的硬币),或者报告不可能以这样的方式选择硬币,使得它们总和为S.
我昨天刚刚介绍了动态编程,我试图为它编写代码.
# Optimal substructure: C[i] = 1 + min_j(C[i-cj])
cdict = {}
def C(i, coins):
if i <= 0:
return 0
if i in cdict:
return cdict[i]
else:
answer = 1 + min([C(i - cj, coins) for cj in coins])
cdict[i] = answer
return answer
在这里,C [i]是金额’i’的最佳解决方案.可用的硬币是{c1,c2,…,cj,…}
对于程序,我增加了递归限制,以避免超出最大递归深度错误.但是,这个程序只给出了正确的答案,当一个解决方案不可能时,它并没有表明这一点.
我的代码有什么问题以及如何纠正它？
解决方法:
这是一个很好的算法问题,但说实话,我不认为你的实现是正确的,或者可能是我不理解你的函数的输入/输出,为此我道歉.
这是您的实施的修改版本.
def C(i, coins, cdict = None):
if cdict == None:
cdict = {}
if i <= 0:
cdict[i] = 0
return cdict[i]
elif i in cdict:
return cdict[i]
elif i in coins:
cdict[i] = 1
return cdict[i]
else:
min = 0
for cj in coins:
result = C(i - cj, coins)
if result != 0:
if min == 0 or (result + 1) < min:
min = 1 + result
cdict[i] = min
return cdict[i]
这是我尝试解决类似的问题,但这次返回一个硬币列表.我最初开始使用递归算法,该算法接受一个金额和一个硬币列表,如果没有找到这样的配置,它可以返回具有最小硬币数量的列表或者无.
def get_min_coin_configuration(sum = None, coins = None):
if sum in coins: # if sum in coins, nothing to do but return.
return [sum]
elif max(coins) > sum: # if the largest coin is greater then the sum, there's nothing we can do.
return None
else: # check for each coin, keep track of the minimun configuration, then return it.
min_length = None
min_configuration = None
for coin in coins:
results = get_min_coin_configuration(sum = sum - coin, coins = coins)
if results != None:
if min_length == None or (1 + len(results)) < len(min_configuration):
min_configuration = [coin] + results
min_length = len(min_configuration)
return min_configuration
好吧现在让我们看看我们是否可以通过使用动态编程来改进它(我只是称之为缓存).
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]
return cache[sum]
elif max(coins) > sum: # if the largest coin is greater then the sum, there's nothing we can do.
cache[sum] = None
return cache[sum]
else: # check for each coin, keep track of the minimun configuration, then return it.
min_length = None
min_configuration = None
for coin in coins:
results = get_min_coin_configuration(sum = sum - coin, coins = coins, cache = cache)
if results != None:
if min_length == None or (1 + len(results)) < len(min_configuration):
min_configuration = [coin] + results
min_length = len(min_configuration)
cache[sum] = min_configuration
return cache[sum]
现在让我们进行一些测试.
assert all([ get_min_coin_configuration(**test[0]) == test[1] for test in
[({'sum':25, 'coins':[1, 5, 10]}, [5, 10, 10]),
({'sum':153, 'coins':[1, 5, 10, 50]}, [1, 1, 1, 50, 50, 50]),
({'sum':100, 'coins':[1, 5, 10, 25]}, [25, 25, 25, 25]),
({'sum':123, 'coins':[5, 10, 25]}, None),
({'sum':100, 'coins':[1,5,25,100]}, [100])] ])
如果这个测试不够健壮,你也可以这样做.
import random
random_sum = random.randint(10**3, 10**4)
result = get_min_coin_configuration(sum = random_sum, coins = random.sample(range(10**3), 200))
assert sum(result) == random_sum
可能没有这样的硬币组合等于我们的random_sum,但我相信它不太可能……
我确信有更好的实现,我试图强调可读性而不是性能.
祝好运.
更新
它以前的代码有一个小错误,它假设检查最小硬币而不是最大值,用pep8合规重新编写算法,当没有找到任何组合而不是None时返回[].
def get_min_coin_configuration(total_sum, coins, cache=None): # shadowing python built-ins is frowned upon.
# assert(all(c > 0 for c in coins)) Assuming all coins are > 0
if cache is None: # initialize cache.
cache = {}
if total_sum in cache: # check cache, for previously discovered solution.
return cache[total_sum]
elif total_sum in coins: # check if total_sum is one of the coins.
cache[total_sum] = [total_sum]
return [total_sum]
elif min(coins) > total_sum: # check feasibility, if min(coins) > total_sum
cache[total_sum] = [] # no combination of coins will yield solution as per our assumption (all +).
return []
else:
min_configuration = [] # default solution if none found.
for coin in coins: # iterate over all coins, check which one will yield the smallest combination.
results = get_min_coin_configuration(total_sum - coin, coins, cache=cache) # recursively search.
if results and (not min_configuration or (1 + len(results)) < len(min_configuration)): # check if better.
min_configuration = [coin] + results
cache[total_sum] = min_configuration # save this solution, for future calculations.
return cache[total_sum]
assert all([ get_min_coin_configuration(**test[0]) == test[1] for test in
[({'total_sum':25, 'coins':[1, 5, 10]}, [5, 10, 10]),
({'total_sum':153, 'coins':[1, 5, 10, 50]}, [1, 1, 1, 50, 50, 50]),
({'total_sum':100, 'coins':[1, 5, 10, 25]}, [25, 25, 25, 25]),
({'total_sum':123, 'coins':[5, 10, 25]}, []),
({'total_sum':100, 'coins':[1,5,25,100]}, [100])] ])
标签：python,algorithm,dynamic-programming 来源： https://codeday.me/bug/20190613/1232966.html