Python中的深度优先搜索

好的，基本上我想做一个深度优先搜索的迷你佩格纸牌游戏。对于那些不熟悉这个游戏的人来说，这很简单

有一块有10个孔和9个销钉的板，销钉用1表示，空位用0表示。你可以一次向后或向前移动两个洞（但你只能移动到一个空洞），如果你在这个过程中跳过另一个洞，你把它拿出来，它就会变成一个洞

下面是一个游戏的样子：

[1, 1, 1, 1, 1, 0, 1, 1, 1, 1]
[1, 1, 1, 0, 0, 1, 1, 1, 1, 1]
[1, 0, 0, 1, 0, 1, 1, 1, 1, 1]
[1, 0, 0, 1, 1, 0, 0, 1, 1, 1]
[1, 0, 0, 0, 0, 1, 0, 1, 1, 1]
[1, 0, 0, 0, 0, 1, 1, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 0, 1, 0, 1] #etc until only 1 peg left

因此，我这里有一个生成器函数，用于查找某个“节点”或游戏板的所有合法移动：

def succ(self, node):
    size = len(node)

    # find all legal moves going forward
    for pos in range(0, size-1):
        new_node = list(node)
        if ((node[pos] == 1) and (pos < (size - 2)) and (node[pos+2] == 0)):
            new_node[pos] = 0  # we're moving now
            new_node[pos+2] = 1 # this is where we're moving the peg to
            new_node[pos+1] = 0  # take out the peg here if there was one
            yield new_node

    # find all legal moves going backwards
    for pos in range(0, size-1):
        new_node = list(node)
        if ((node[pos] == 1) and (pos > 1) and (node[pos-2] == 0)):
            new_node[pos] = 0  # we're moving now
            new_node[pos-2] = 1 # this is where we're moving the peg
            new_node[pos-1] = 0  # take out the peg here if there was one
            yield new_node

---

因此，基本上我认为我的succ（）函数做的是正确的（也许不是？），但我的solve_board（）递归可能有点古怪，因为board没有解。

我没有对你的succ（）函数进行解密，但假设它能工作，那么程序的其余部分确实会进行深度优先搜索。我认为代码没有终止？如果succ可以返回以前遇到的状态，那么您可能会有一个无限决策树，深度优先搜索可能会在无限分支上受阻，并错过另一个分支上的正确解决方案。在这种情况下，您需要使用广度优先搜索。

因为您可以跳过空洞，所以您必须跟踪您已经访问过的任何节点。否则，将有一个无限循环

除非你已经找到了一个目标，否则你也不需要缩短for循环

tested_nodes=set()
def solve_board(dfs_obj, node):
    if goal(node):  # only 1 peg!
        print node
        return node

    for new_node in succ(node):
        if tuple(new_node) not in tested_nodes:
            tested_nodes.add(tuple(new_node))
            print new_node
            result = solve_board(new_node)
            if result:  # True if it's a goal, None otherwise
                return result

您的succ函数中的范围也有错误，您不应该从范围的大小中将第1项细分。您也可以这样重写它，以便从

if

def succ(self, node):
    size = len(node)

    # find all legal moves going forward
    for pos in range(size-2):
        new_node = list(node)
        if ((node[pos] == 1) and (node[pos+2] == 0)):
            new_node[pos] = 0  # we're moving now
            new_node[pos+2] = 1 # this is where we're moving the peg to
            new_node[pos+1] = 0  # take out the peg here if there was one
            yield new_node

    # find all legal moves going backwards
    for pos in range(1,size):
        new_node = list(node)
        if ((node[pos] == 1) and (node[pos-2] == 0)):
            new_node[pos] = 0  # we're moving now
            new_node[pos-2] = 1 # this is where we're moving the peg
            new_node[pos-1] = 0  # take out the peg here if there was one
            yield new_node

编写成功函数的另一种方法是

def succ(self, node):
    for i in range(len(node)-2):
        j=i+3
        if node[i:j]==[1,1,0]:
            yield node[:i]+[0,0,1]+node[j:]
        if node[i:j]==[0,1,1]:
            yield node[:i]+[1,0,0]+node[j:]
        if node[i:j]==[1,0,0]:
            yield node[:i]+[0,0,1]+node[j:]
        if node[i:j]==[0,0,1]:
            yield node[:i]+[1,0,0]+node[j:]

---

这会先稍微调整深度，因为更喜欢移除挂钩的动作

是的，这些回答都没有任何帮助，因为没有一个答案遵循我必须使用的界面（即succ（）函数）。我也讨厌人们喜欢给出神秘的答案，我是说，来吧，帮帮我，这样我就可以喝掉我悲惨的生活了。你认为这就是这里发生的事情吗？我的意思是，我们意识到深度优先可能导致无限循环，但老师让我们觉得我们应该能够得到一个有效的解决方案。上帝啊，我的生命，你不能跳过一个空的hole@Caludiu当前位置一开始我也是这么想的，但请重新阅读问题谢谢你，格尼布勒。是的，你可以跳过一个空洞。

def succ(self, node):
    for i in range(len(node)-2):
        j=i+3
        if node[i:j]==[1,1,0]:
            yield node[:i]+[0,0,1]+node[j:]
        if node[i:j]==[0,1,1]:
            yield node[:i]+[1,0,0]+node[j:]
        if node[i:j]==[1,0,0]:
            yield node[:i]+[0,0,1]+node[j:]
        if node[i:j]==[0,0,1]:
            yield node[:i]+[1,0,0]+node[j:]