Question

我有一个简单的递归函数，它提供了一个深度优先搜索选项列表的每个可能组合：

def twoCharacters_dfs(options, used):
    for i in range(len(options)):
        used.append(options.pop(0))
        print("used=", used)
        twoCharacters_dfs(options, used)
    if len(used) == 0:
        return
    options.append(used.pop())

twoCharacters_dfs(['q', 'w', 'e', 'r'], [])

输出（由于长度而缩短）如下所示：

used= ['q']
used= ['q', 'w']
used= ['q', 'w', 'e']
used= ['q', 'w', 'e', 'r']
used= ['q', 'w', 'r']
used= ['q', 'w', 'r', 'e']
used= ['q', 'e']
used= ['q', 'e', 'r']
used= ['q', 'e', 'r', 'w']
used= ['q', 'e', 'w']
used= ['q', 'e', 'w', 'r']
....
used= ['w']
....
used= ['e']
....
used= ['r']
....

这一切都很好，并且按照我的意愿行事。但我有兴趣将其从深度优先转换为广度，因此输出看起来更像：

used= ['q']
used= ['w']
used= ['e']
used= ['r']
used= ['q', 'w']
used= ['q', 'e']
used= ['q', 'r']
used= ['w', 'q']
used= ['w', 'e']
used= ['w', 'r']
....

我有点能够（只有一个硬编码的固定长度列表）迭代地执行它，但是需要一个递归解决方案，因此它可以适用于任何长度的选项。我也故意避免提供我所寻求的功能的python库，因为我想了解事情是如何工作的，并构建我自己的东西作为学习练习。

我觉得有一个简单的解决方案，但我无法将广度优先算法概念化为我的代码。

更新

在尝试递归BFS解决方案之前，我想创建一个迭代BFS解决方案，因为它似乎更容易实现。事实证明，我也很难做到这一点。

def twoCharacters_bfs_iterative(options, used):
    for option in options:
        print("using option = ", option)

    for option1 in options:
        list2 = options[:]
        list2.remove(option1)
        for option2 in list2:
            print("using option = ", option1, option2)

    for option1 in options:
        list2 = options[:]
        list2.remove(option1)
        for option2 in list2:
            list3 = list2[:]
            list3.remove(option2)
            for option3 in list3:
                print("using option = ", option1, option2, option3)

这实现了我想要的输出（如上所列），但仅适用于我知道长度的集合。我想将它扩展为一个任意长度的列表，但我很难做到这一点。我想如果我能让迭代解决方案工作，那么递归解决方案就不会落后了。

Answer 1

编辑：我没有从示例中注意到所有排列都是必需的。遵循使用列表作为队列的函数：

def bfs(options):
    queue = [([c], [*options[:i], *options[i+1:]]) for i,c in enumerate(options)]
    while len(queue) > 0:
        head, tail = queue[0]
        print(head)
        queue.extend([([*head, c], [*tail[:i], *tail[i+1:]]) for i,c in enumerate(tail)])
        del queue[0]

这样工作（64行，截断）：

>>> bfs(['q','w','e','r'])
['q']
['w']
['e']
['r']
['q', 'w']
['q', 'e']
...
['r', 'w']
['r', 'e']
['q', 'w', 'e']
['q', 'w', 'r']
['q', 'e', 'w']
...
['r', 'q', 'e', 'w']
['r', 'w', 'q', 'e']
['r', 'w', 'e', 'q']
['r', 'e', 'q', 'w']
['r', 'e', 'w', 'q']

此外，

def bfs(options):
    queue = [([c], [*options[:i], *options[i+1:]]) for i,c in enumerate(options)]
    for head, tail in queue:
        queue.extend([([*head, c], [*tail[:i], *tail[i+1:]]) for i,c in enumerate(tail)])
    return [head for head, tail in queue]

此版本返回列表而不是打印。

按照上一个答案，不考虑排列：

正如其他人在评论中已经说过的那样，这并不自然。遵循＆＃34;递归＆＃34;功能：

def bfs(options, level=0):
    if level == 0:
        for c in options:
            print([c])
        for i in range(1,len(options)):
            bfs(options, i)
    else:
        for i,c in enumerate(options):
            for j,g in enumerate(options[i+1:]):
                if i+1+j+level <= len(options):
                    print([c,*options[i+1+j:i+1+j+level]])

最后一行中的*需要Python3，但您可以删除它。

预期输出为：

['q']
['w']
['e']
['r']
['q', 'w']
['q', 'e']
['q', 'r']
['w', 'e']
['w', 'r']
['e', 'r']
['q', 'w', 'e']
['q', 'e', 'r']
['w', 'e', 'r']
['q', 'w', 'e', 'r']

另一个版本：

def bfs(options, level=0):
    for i,c in enumerate(options):
        for j,g in enumerate(options[i+1:]):
            if i+1+j+level <= len(options):
                print([c,*options[i+1+j:i+1+j+level]])
            if level == 0:
                break
    if level < len(options):
        bfs(options, level + 1)

Answer 2

我正在为自己的问题发布一个答案，以提供有关深度优先搜索和广度优先搜索的一些清晰度。我最初的目标是递归深度优先函数的递归广度第一版。这是因为缺乏对DFS和BFS之间基本区别的理解：DFS使用堆栈而BFS使用队列。（感谢@Patrick Haugh的见解以及这篇文章：Performing Breadth First Search recursively）。

DFS使用堆栈这一事实很适合递归函数，因为您可以将调用堆栈用作操作堆栈。但这不适用于BFS的队列样式。广度优先搜索可以递归地完成，但最终类似于一个错误的深度优先搜索。将BF作为迭代函数保持清晰和直观。

在没有理解其工作原理的情况下，再也不是复制/粘贴代码的粉丝，@ Matteo T.正确答案引导我进入迭代BFS解决方案，而不是我目前正在实施的枚举：

def bfs_iterative(options):
    queue = [[item] for item in options]
    while queue:
        using = queue.pop(0)
        print(using)
        remaining = [item for item in options if item not in using]
        extension = []
        for item in remaining:
            using.append(item)
            extension.append(using[:])
            using.pop()
        queue.extend(extension)

Python：将深度优先搜索转换为广度优先搜索列表的所有组合

2 个答案: