BFS广度优先搜索解决八数码问题(python代码超详细注释)

使用广度优先搜索算法解决八数码问题的步骤如下：

1. 定义状态表示：将八数码问题的状态表示为一个3x3的矩阵，矩阵中的每个元素表示棋盘上的一个方块，空白方块用0表示。

2. 初始化：将初始状态作为搜索的起始点，并将其设为当前状态。创建一个队列（通常是先进先出的队列）用于存储待扩展的状态。

3. 扩展状态：对当前状态进行扩展，即生成所有可能的下一步状态。通过将空白方块与相邻的方块进行交换来生成新状态。

4. 检查目标：在每次扩展状态时，检查新生成的状态是否达到了目标状态（通常是按照从左到右、从上到下的顺序排列的状态）。如果达到了目标状态，则搜索结束，找到了解决方案。

5. 更新状态：将新生成的状态添加到队列中，作为待扩展的状态。

6. 重复步骤3至5：从队列中取出下一个待扩展的状态，重复步骤3至5，直到队列为空或找到了目标状态。

7. 回溯路径：如果找到了目标状态，可以通过记录每个状态的父状态来回溯搜索路径，直到回溯到初始状态，得到解决八数码问题的移动序列。

广度优先搜索保证可以找到最短路径，但是在搜索过程中可能需要存储大量的状态，所以对于复杂的八数码问题可能需要较大的存储空间和计算时间。

python代码:

from collections import deque


def breadth_first_search(initial_state, goal_state):
    queue = deque()  # 创建一个双端队列用于存储待扩展的状态
    visited = set()  # 创建一个集合用于存储已访问的状态，以避免重复访问
    parent = {}  # 创建一个字典用于记录每个状态的父状态，用于回溯路径

    queue.append(initial_state)  # 将初始状态加入队列
    visited.add(tuple(initial_state))  # 将初始状态转换为元组并加入已访问集合
    parent[tuple(initial_state)] = None  # 初始状态没有父状态，设为None

    while queue:
        current_state = queue.popleft()  # 取出队列中的第一个状态作为当前状态

        if current_state == goal_state:
            # 找到了目标状态，回溯路径
            path = []
            while current_state:
                path.append(current_state)
                current_state = parent[tuple(current_state)]
            path.reverse()
            return path

        next_states = generate_next_states(current_state)  # 生成下一步可能的状态

        for next_state in next_states:
            if tuple(next_state) not in visited:
                queue.append(next_state)
                visited.add(tuple(next_state))
                parent[tuple(next_state)] = current_state  # 记录下一步状态的父状态为当前状态

    return None  # 如果队列为空仍然没有找到目标状态，表示无解


def generate_next_states(state):
    next_states = []
    blank_index = state.index(0)  # 找到空白方块的索引

    adjacent_indices = get_adjacent_indices(blank_index)  # 获取可以移动的方块的索引

    for index in adjacent_indices:
        new_state = list(state)  # 创建当前状态的副本
        new_state[blank_index] = new_state[index]  # 将空白方块与相邻方块交换
        new_state[index] = 0
        next_states.append(new_state)  # 添加生成的新状态到下一步状态列表

    return next_states


def get_adjacent_indices(index):
    adjacent_indices = []

    if index // 3 > 0:
        adjacent_indices.append(index - 3)  # 上方方块
    if index // 3 < 2:
        adjacent_indices.append(index + 3)  # 下方方块
    if index % 3 > 0:
        adjacent_indices.append(index - 1)  # 左侧方块
    if index % 3 < 2:
        adjacent_indices.append(index + 1)  # 右侧方块

    return adjacent_indices


def print_state(state):
    for i in range(0, 9, 3):
        print(state[i:i + 3])
        if i == 6:
            print()


# 测试示例
initial_state = [2, 8, 3, 1, 0, 4, 7, 6, 5]
goal_state = [1, 2, 3, 8, 0, 4, 7, 6, 5]

path = breadth_first_search(initial_state, goal_state)

if path:
    print("找到了解决方案：")
    for state in path:
        print_state(state)
else:
    print("无解")

 运行结果:

一些关键的心得体会：

1. 状态空间的组织：八数码问题可以看作是一个状态空间搜索问题，其中每个状态都是一个具有不同数字排列的八数码板。在实现BFS时，我发现合理组织和表示状态空间是非常重要的。在代码示例中，我使用了列表来表示状态，通过数字的排列和空白方块的位置来表示不同的状态。

2. 队列的作用：BFS使用队列来存储待扩展的状态，并按照先进先出的顺序进行状态扩展。队列的特性确保我们先扩展当前层的状态，然后才能扩展下一层的状态。这种按层级扩展的方式确保我们能够找到最短路径。

3. 状态去重：在八数码问题中，存在许多状态是等效的，即它们可能具有相同的数字排列，只是排列顺序不同。为了避免重复扩展相同的状态，我使用了一个集合来存储已经访问过的状态。在将状态添加到集合之前，将其转换为元组以确保不可变性。

4. 路径回溯：BFS仅能找到最短路径，而无法记录详细的路径信息。因此，在找到目标状态后，我实现了一种简单的路径回溯方法，通过记录每个状态的父状态，从目标状态回溯到起始状态，以获取完整的路径。

5. 时间和空间复杂度：BFS具有良好的完备性和最优性，但其时间和空间复杂度随着状态空间的增大而增加。在解决大规模八数码问题时，可能需要更高效的搜索算法或优化措施。