组合递归算法

Question

我需要编写一个递归函数，在 Python 中计算列表中长度“n”的所有可能组合，而无需导入 itertools 等任何内容。

所以我到目前为止是：

if n == 0:
    return [[]]
elif lst == []:
    return []
else:
    rest = subsets(lst[1:], n-1)
    for next in lst:  # Loop through something?
        return lst[0] + rest #Add something?

我似乎对递归调用的工作原理缺乏了解，有人可以向我解释一下吗？

Answer 1

在没有所需的输出规范的情况下，我们可以编写一些伪代码，如下所示：

def combinations(sub, data_set, items_needed):
    if you dont need, return sub
    for item in data_set:
        append item to sub
        #pop() item from data_set?
        decrease items_needed # added one more, so we need one less
        combinations(new_sub, data_set, items_needed)

poping() 与否取决于您想要（或不想要）子集中的唯一项目。

如果您说不想同时使用 [a, b] 和 [b, a]，您还必须跟踪添加的最后一个项目的索引，以便仅添加新项目以创建新组合.

def combinations(sub, data_set, index, still_needed):
    if you dont need any, return
    for i in range(index, len(data_set)):
        append data_set[i] to sub
        decrease still_needed
        combinations(sub, data_set, index+1, still_needed)

Answer 2

这听起来很危险，就像一个家庭作业问题。为什么它必须是递归的，因为这看起来很糟糕。

无论如何，递归地你正在做的是遍历列表中的每个元素，然后将其附加到长度为 n - 1 的所有其他组合的开头。所以，如果你的列表是 [1, 2, 3]，你想要一个调用堆栈看起来像这样的算法：

foo([], [1, 2, 3], n) ==
  foo([1], [2, 3], n - 1) +
  foo([2], [1, 3], n - 1) +
  foo([3], [1, 2], n - 1)

在哪里，

foo([1], [2, 3], n - 1) ==
  foo([1, 2], [3], n - 2) +
  foo([1, 3], [2], n - 2)

等等……

只要 n == 0 或中间列表为空，您就可以终止递归调用。你只需返回第一个参数。

这一切都有意义吗？ （如果需要，我可以对其进行编码。我认为如果您查看所需的调用堆栈，它应该主要将自己放在一起。）

Answer 3

面对这样一个基本问题（经常用作入门级作业或在某些编程面试中使用的问题）时，一个有用的技巧是查看RosetteCode（您也可以从中学习如何打动您的朋友像“chrestomathy”这样的词）。对于这一点，我们特别发现：

#/usr/bin/env python
# From: http://rosettacode.org/wiki/Combinations#Python
def comb(m, lst):
if m == 0:
    return [[]]
else:
    return [[x] + suffix for i, x in enumerate(lst)
            for suffix in comb(m - 1, lst[i + 1:])]

...与几十种其他语言的实现一起进行比较。

另一个方便的站点是PLEAC（用于“Programming Language Examples Alike Cookbook”项目）......虽然它的学术性较低，并且倾向于更实用的编程任务。