因此，逻辑是将数字进行逆排序，并假设数字列表为
l ，要形成的总和为
s 。
for i in b:
if(a(round(n-i,2),b[b.index(i)+1:])):
r.append(i)
return True
return False
然后，我们通过这个循环并按顺序从
l 中选择一个数字, 假设是
i。
有两种可能的情况，
i 是解的一部分或者不是。
所以，我们假设
i 是解的一部分，然后问题就变成了
l 变为
l[l.index(i+1):]，
s 变为
s-i。因此，如果我们的函数是 a(l,s)，那么我们调用
a(l[l.index(i+1):], s-i)。如果
i 不是
s 的一部分，则我们必须从
l[l.index(i+1):] 列表中组合出
s。
因此，在两种情况下都是类似的，唯一的区别在于如果 i 是 s 的一部分，则 s = s-i，否则 s = s。
现在，为了简化问题，如果 l 中的数字大于 s，我们将它们删除以减少复杂性，直到 l 为空，在这种情况下，所选择的数字不是我们解的一部分，并返回 false。
if(len(b)==0):
return False
while(b[0]>n):
b.remove(b[0])
if(len(b)==0):
return False
如果l只剩下一个元素，那么它要么是s的一部分，我们返回true；要么不是，我们返回false并循环遍历其他数字。
if(b[0]==n):
r.append(b[0])
return True
if(len(b)==1):
return False
注意循环中如果使用了b，但是b只是我们的列表。我已经尽可能地对其进行了四舍五入，以避免在Python中进行浮点数计算时得到错误的答案。
r=[]
list_of_numbers=[61.12,13.11,100.12,12.32,200,60.00,145.34,14.22,100.21,14.77,214.35,200.32,65.43,0.49,132.13,143.21,156.34,11.32,12.34,15.67,17.89,21.23,14.21,12,122,134]
list_of_numbers=sorted(list_of_numbers)
list_of_numbers.reverse()
sum_to_be_formed=401.54
def a(n,b):
global r
if(len(b)==0):
return False
while(b[0]>n):
b.remove(b[0])
if(len(b)==0):
return False
if(b[0]==n):
r.append(b[0])
return True
if(len(b)==1):
return False
for i in b:
if(a(round(n-i,2),b[b.index(i)+1:])):
r.append(i)
return True
return False
if(a(sum_to_be_formed,list_of_numbers)):
print(r)
这个解决方案速度很快，比上面解释的方法更快。但是只适用于正数。同样地，如果没有可行解，它将花费太多时间才能退出循环。
例如，运行如下：
l=[1,6,7,8,10]
and s=22 i.e. s=1+6+7+8
so it goes through like this
1.) [10, 8, 7, 6, 1] 22
i.e. 10 is selected to be part of 22..so s=22-10=12 and l=l.remove(10)
2.) [8, 7, 6, 1] 12
i.e. 8 is selected to be part of 12..so s=12-8=4 and l=l.remove(8)
3.) [7, 6, 1] 4
now 7,6 are removed and 1!=4 so it will return false for this execution where 8 is selected.
4.)[6, 1] 5
i.e. 7 is selected to be part of 12..so s=12-7=5 and l=l.remove(7)
now 6 are removed and 1!=5 so it will return false for this execution where 7 is selected.
5.)[1] 6
i.e. 6 is selected to be part of 12..so s=12-6=6 and l=l.remove(6)
now 1!=6 so it will return false for this execution where 6 is selected.
6.)[] 11
i.e. 1 is selected to be part of 12..so s=12-1=1 and l=l.remove(1)
now l is empty so all the cases for which 10 was a part of s are false and so 10 is not a part of s and we now start with 8 and same cases follow.
7.)[7, 6, 1] 14
8.)[6, 1] 7
9.)[1] 1
仅仅为了做一个比较，我在我的电脑上运行了一下，这台电脑性能不是很好。使用...
l=[61.12,13.11,100.12,12.32,200,60.00,145.34,14.22,100.21,14.77,214.35,145.21,123.56,11.90,200.32,65.43,0.49,132.13,143.21,156.34,11.32,12.34,15.67,17.89,21.23,14.21,12,122,134]
并且
s=2000
我的循环运行了1018次，花费了31毫秒。
而之前的代码循环运行了3415587次，大约需要16秒的时间。
然而，如果不存在解决方案，我的代码会运行超过几分钟，所以我停止了它，而之前的代码只需要大约17毫秒，而且可以处理负数。
因此，我认为有些改进可以进行。
