Question

我很难理解为什么以下递归代码（函数count（））给出了错误的计算次数，但是基于手动编写的嵌套for循环（函数count2（））给出了正确的计数，这是n！ * 4 ^（n-1）？

（在这一点上别担心输出变量。如果我能先解决这个难题，我以后再使用它。）

我希望创建一个递归函数，可以为任意长度的列表创建计算，这就是为什么简单地嵌套for循环不够好。

import itertools
import operator
# http://stackoverflow.com/questions/2983139/assign-operator-to-variable-in-python
ops = {
    0: operator.add,
    1: operator.sub,
    2: operator.mul,
    3: operator.truediv
}
comb = [4, 1, 2, 3]
perms = list()
# itertools.permutations is not subscriptable, so this is a mandatory step.
# See e.g. http://stackoverflow.com/questions/216972/in-python-what-does-it-mean-if-an-object-is-subscriptable-or-not
# for details.
for i in itertools.permutations(comb):
    perms.append(i)
output = list()
output2 = list()

# In theory, there are n! * 4 ^ (n-1) possibilities for each set.
# In practice however some of these are redundant, because multiplication and
# addition are indifferent to calculation order. That's not tested here;
# nor is the possibility of division by zero.

# Variable debug is there just to enable checking the calculation count;
# it serves no other purpose.
debug = list()
debug2 = list()

def count(i):
    for j in range(len(i)):
        for op in ops:
            if j+1 < len(i):
                res = ops[op](i[j], i[j+1])
                if j+2 < len(i):
                    ls = list(i[j+1:])
                    ls[0] = res
                    count(ls)
                else:
                    debug.append([len(i), i[j], ops[op], i[j+1], res])
                    if res == 10: output.append(res)

def count2(i):
    for j in range(len(i)):
        for op in ops:
            if j+1 < len(i):
                res = ops[op](i[j], i[j+1])
                for op2 in ops:
                    if j+2 < len(i):
                        res2 = ops[op2](res, i[j+2])
                        for op3 in ops:
                            if j+3 < len(i):
                                res3 = ops[op3](res2, i[j+3])
                                debug2.append(res3)
                                if res3 == 10: output2.append(res3)

for i in perms:
    count(i)
    count2(i)
print(len(debug)) # The result is 2400, which is wrong.
print(len(debug2)) # The result is 1536, which is correct.

Answer 1

您在递归函数中附加了太多的重新连接。让我详细说明你的例子。我们只考虑计算原始排列。电话

count([4, 1, 2, 3])

应该导致以下递归调用：

count([5, 2, 3])  # +
count([3, 2, 3])  # -
count([4, 2, 3])  # *
count([4, 2, 3])  # /

它不应该附加任何结果，对吧！但是，由于您在顶级调用中循环索引，因此它还会导致以下所有递归调用：

count([3, 3])   # these calls are premature
count([-1, 3])  # since they reduce 1, 2
count([2, 3])   # and do not consider
count([0.5, 3]) # the first element 4

并附加所有[2, 3]计算的结果，这同样太早了！

你在递归函数中真正想做的是，只减少第一对元素（不是每对相邻元素！），然后递归计数结果列表的计算。因此，您的功能可以简化为：

def count(lst):
    # no mo' looping through the list. That's why we do recursion!
    for op in ops.values():
        if len(lst) > 1:
            res = op(*lst[:2])  # reduce first pair
            if len(lst) > 2: 
                ls_short = [res] + list(lst[2:])
                count(ls_short)
            else:
                debug.append(res)

...
> print(len(debug)) 
1536

递归地生成Python中set元素之间的所有可能计算

1 个答案: