分别使用广度优先与深度优先策略处理迷宫问题。比较路径搜索过程中的节点扩展顺序。用py实现，并输出路径

好的，这里分别使用广度优先和深度优先算法处理迷宫问题，比较节点扩展顺序。这是Python代码示例：

from collections import deque

maze = [[0, 1, 0, 0, 0],
        [0, 1, 0, 1, 0],
        [0, 0, 0, 0, 0],
        [0, 1, 1, 1, 0],
        [0, 0, 0, 1, 0]] # 迷宫地图，0 表示可以通过，1 表示障碍物

def bfs(start, end):
    queue = deque([start])
    visited = set([start])
    parent = {start: None}
    while queue:
        x, y = queue.popleft()
        if (x, y) == end: # 到达终点
            path = []
            while (x, y) != start:
                path.append((x, y))
                x, y = parent[(x, y)]
            path.append(start)
            path.reverse()
            return path
        for nx, ny in [(x-1, y), (x+1, y), (x, y-1), (x, y+1)]: # 上下左右四个方向
            if 0 <= nx < len(maze) and 0 <= ny < len(maze[0]) and maze[nx][ny] == 0 and (nx, ny) not in visited:
                queue.append((nx, ny))
                visited.add((nx, ny))
                parent[(nx, ny)] = (x, y)
    return None

def dfs(start, end):
    stack = [start]
    visited = set([start])
    parent = {start: None}
    while stack:
        x, y = stack.pop()
        if (x, y) == end: # 到达终点
            path = []
            while (x, y) != start:
                path.append((x, y))
                x, y = parent[(x, y)]
            path.append(start)
            path.reverse()
            return path
        for nx, ny in [(x-1, y), (x+1, y), (x, y-1), (x, y+1)]: # 上下左右四个方向
            if 0 <= nx < len(maze) and 0 <= ny < len(maze[0]) and maze[nx][ny] == 0 and (nx, ny) not in visited:
                stack.append((nx, ny))
                visited.add((nx, ny))
                parent[(nx, ny)] = (x, y)
    return None

start = (0, 0)
end = (len(maze)-1, len(maze[0])-1)

# 广度优先搜索
bfs_path = bfs(start, end)
if bfs_path:
    print("广度优先搜索找到了一条路径：", end="")
    for p in bfs_path:
        print("({},{}) -> ".format(p[0], p[1]), end="")
    print()
else:
    print("广度优先搜索没有找到路径！")

# 深度优先搜索
dfs_path = dfs(start, end)
if dfs_path:
    print("深度优先搜索找到了一条路径：", end="")
    for p in dfs_path:
        print("({},{}) -> ".format(p[0], p[1]), end="")
    print()
else:
    print("深度优先搜索没有找到路径！")

这个示例中，我们先实现了两个函数 `bfs` 和 `dfs`，分别使用广度优先和深度优先算法搜索迷宫。在搜索过程中，我们使用一个哈希集合 `visited` 记录已经访问过的节点，使用一个字典 `parent` 记录每个节点的父节点，从而构建出最终的路径。最后我们分别调用 `bfs` 和 `dfs` 函数，找到一条路径到达终点 $(4, 4)$，并输出路径结果。