为什么我的程序运行无限循环？python

我正在尝试使用广度优先搜索在python中创建迷宫解算器。该算法将从S到E（起点到终点）的最短路径替换为1。然而，我的程序正在运行一个无限循环，我唯一的while循环是在末尾，所以我认为问题就在那里。我不知道是什么引起的

import queue


def maze_3():
    maze3 = [
        '00000S000000000000000000000000000000000000000000000000000000000',
        '00000  000000000                                               ',
        '00000  000000000  000000000000000000  000000000000000  00000000',
        '000000            00000000    000000                      00000',
        '   00000000  000000000000         000000000000000000     000000',
        '00000000         000000000000000000000000000000   0000   000000',
        '000000        000      000000000      000     000000       0000',
        '000000  000     000000000        00000000    000000          00',
        '00  000    0  0000000000  000  000   0000  00  00 00000     000',
        '000000    000000         000000000     000  0000          00000',
        '0000000000000000            0000000  0000000   000  00000000000',
        '000000        000  0000000    0000   00000000000000    00000000',
        '0000000000000000E                                       0000000',
    ]
    return maze3


def finished_maze(maze, solution=''):
    global starting_point
    for i, position in enumerate(maze[0]):
        if position == 'S':
            starting_point = i

    j = starting_point
    k = 0
    position = set()

    for move in solution:
        if move == 'Up':
            k -= 1
        elif move == 'Down':
            k += 1
        elif move == 'Left':
            j -= 1
        elif move == 'Right':
            j += 1

    for k, row in enumerate(maze):
        for j, column in enumerate(row):
            if (k, j) in position:
                print('1', end='')
            else:
                print(column, end='')
        print()


def is_valid(maze, moves):
    a = True
    for l, position in enumerate(maze[0]):
        if position == 'S':
            starting_point = l

    j = starting_point
    k = 0

    for move in moves:
        if move == 'Up':
            k -= 1
        elif move == 'Down':
            k += 1
        elif move == 'Left':
            j -= 1
        elif move == 'Right':
            j += 1

        if not ((j >= 0 and j < len(maze[0])) and (k >= 0 and k < len(maze[0]))):
            return not a
        elif maze[k][j] == '0':
            return not a
    return a


def find_solution(maze, moves):
    a = True
    for i, position in enumerate(maze[0]):
        if position == 'S':
            starting_point = i

    j = starting_point
    k = 0
    for move in moves:
        if move == 'Up':
            k -= 1
        elif move == 'Down':
            k += 1
        elif move == 'Left':
            j -= 1
        elif move == 'Right':
            j += 1

        if maze[k][j] == 'E':
            print(finished_maze(maze, moves))
            return a

    return not a


space = queue.Queue()
space.put('')
put = ''
maze = maze_3()

while not find_solution(maze, put):
    put = space.get()
    for i in ['Up', 'Down', 'Left', 'Right']:
        location = put + i
        if is_valid(maze, location):
            space.put(location)

导入队列
def maze_3（）：
maze3=[
'00000S000000000000000000000000000000000000000000000'，
'00000  000000000                                               ',
'00000  000000000  000000000000000000  000000000000000  00000000',
'000000            00000000    000000                      00000',
'   00000000  000000000000         000000000000000000     000000',
'00000000         000000000000000000000000000000   0000   000000',
'000000        000      000000000      000     000000       0000',
'000000  000     000000000        00000000    000000          00',
'00  000    0  0000000000  000  000   0000  00  00 00000     000',
'000000    000000         000000000     000  0000          00000',
'0000000000000000            0000000  0000000   000  00000000000',
'000000        000  0000000    0000   00000000000000    00000000',
“0000000000000000 E 0000000”，
]
返回迷宫3
def完成_迷宫（迷宫，溶液=“”）：
全球起点
对于i，枚举中的位置（迷宫[0]）：
如果位置=='S'：
起点=i
j=起点
k=0
位置=集合（）
对于入住解决方案：
如果移动==“向上”：
k-=1
elif move==“向下”：
k+=1
elif move==“左”：
j-=1
elif move==“Right”：
j+=1
对于k，枚举（迷宫）中的行：
对于j，枚举（行）中的列：
如果（k，j）处于适当位置：
打印（'1'，结束=''）
其他：
打印（列，结束=“”）
打印（）
def有效（迷宫、移动）：
a=正确
对于l，枚举中的位置（迷宫[0]）：
如果位置=='S'：
起点=l
j=起点
k=0
对于移入移动：
如果移动==“向上”：
k-=1
elif move==“向下”：
k+=1
elif move==“左”：
j-=1
elif move==“Right”：
j+=1
如果不是（（j>=0和j=0和k

这一行代码没有达到您期望的效果：

对于移入移动：

它将其拆分，以便将每个字母分别发送给您

D
o
w
n
D
o
w
n

应该是这样的：（将

import re

添加到文件的开头）

对于移入findall（“[A-Z][^A-Z]*”，移动）：

它提供了以下内容：

Right
Down
Down
Up
Up
Down
Down
Up
Down
Down
Down
Up
Left
Down
Down
Up
Right

除此之外，您的程序工作正常，但速度非常慢，因为您没有检查是否已访问某个节点

访问列表中的额外部分

如果您这样定义迷宫：

def maze_3（）：
maze3=[
'00000S000000000000000000000000000000000000000000000'，
'00000  000000000                                               ',
'00000  000000000  000000000000000000  000000000000000  00000000',
“000000E 00000000000000000000000”，这里我们添加一个E
'   00000000  000000000000         000000000000000000     000000',
'00000000         000000000000000000000000000000   0000   000000',
'000000        000      000000000      000     000000       0000',
'000000  000     000000000        00000000    000000          00',
'00  000    0  0000000000  000  000   0000  00  00 00000     000',
'000000    000000         000000000     000  0000          00000',
'0000000000000000            0000000  0000000   000  00000000000',
'000000        000  0000000    0000   00000000000000    00000000',
“0000000000000000 E 0000000”，
]
返回迷宫3

它给出了以下正确的解决方案：

Down
Down
Right
Down

但如果我们打印它检查的所有路径，我们可以看到：

Up
Down
Left
Right
DownUp
...

---

最后一行表示它返回到已经访问过的位置。如果您更好地查看BFS，您将看到它保存了一个已访问节点的列表。如果添加它，它将加快代码的速度，因为您不会检查已经访问过的节点。

我认为创建maze_3（）函数没有任何用处。您可以只使用一个值为mazeal的字符串，也可以只存储移动的元组，这样就不需要使用正则表达式