1． 迷宫最短路径问题： 由 0 和 1 构成的 n 维方阵 M 表示一个迷宫，其中 0 表示通路， 1 表示墙壁。迷宫 入口为(0,0),出口为(n-1,n-1)。迷宫随机产生。试编一算法求出从入口点到出口点 可沿八个方向前进的最短路径。2． 程序要求： ⚫ 程序输入： n（可用 10 进行测试。） ⚫ 程序处理： 随机生成由 0 和 1 构成的 n 维方阵 M， 设置入口（0， 0）， 出口 （n-1， n-1） 为 0。 求出从入口到出口的最短路径。 ⚫ 程序输出： 先输出迷宫， 即方阵 M。 如果存在最短路径， 则输出路径长度， 以及对应的从入口到出口所经过的每个矩阵点坐标； 否则， 输出“此迷宫不 存在最短路径。”

好的，我理解了你的问题。这是一个比较经典的迷宫问题，可以使用广度优先搜索（BFS）算法求解。下面是一个基于Python的BFS算法实现：

from collections import deque

# 定义迷宫的八个方向
directions = [(1, 0), (0, 1), (-1, 0), (0, -1), (1, 1), (-1, 1), (1, -1), (-1, -1)]

def BFS(maze):
    n = len(maze)
    # 定义起点和终点
    start, end = (0, 0), (n-1, n-1)
    # 定义队列和visited数组，visited数组用于记录每个节点是否已被访问
    queue, visited = deque([(start, 0)]), set([start])
    while queue:
        # 从队列中取出一个节点
        (x, y), steps = queue.popleft()
        # 如果当前节点是终点，返回路径长度和路径列表
        if (x, y) == end:
            path = [(x, y)]
            while (x, y) != start:
                for dx, dy in directions:
                    if (x-dx, y-dy) in visited:
                        x, y = x-dx, y-dy
                        path.append((x, y))
                        break
            return steps, list(reversed(path))
        # 否则，对当前节点的所有相邻节点进行搜索
        for dx, dy in directions:
            new_x, new_y = x+dx, y+dy
            if 0<=new_x<n and 0<=new_y<n and maze[new_x][new_y] == 0 and (new_x, new_y) not in visited:
                queue.append(((new_x, new_y), steps+1))
                visited.add((new_x, new_y))
    # 如果无法到达终点，返回None
    return None

# 测试代码
n = 10
maze = [[0 if random.random()<0.7 else 1 for j in range(n)] for i in range(n)]
maze[0][0], maze[n-1][n-1] = 0, 0
print("迷宫：")
for row in maze:
    print(row)
result = BFS(maze)
if result:
    print("最短路径长度：", result[0])
    print("路径坐标：", result[1])
else:
    print("此迷宫不存在最短路径。")

在这个实现中，我们定义了一个 `BFS` 函数来执行BFS算法。函数中使用了一个队列来存储待访问的节点，以及一个 `visited` 集合来记录已经访问过的节点。在每次循环中，我们从队列中取出一个节点 `(x,y)`，然后对它的八个相邻节点进行搜索。如果相邻节点是合法的（即在迷宫范围内，且未被访问过，并且是通路），那么我们将这个节点加入到队列中，并将它加入到 `visited` 集合中。如果相邻节点是终点，那么我们就可以通过搜索路径回溯算法得到最短路径。回溯算法的实现如下：

path = [(x, y)]
while (x, y) != start:
    for dx, dy in directions:
        if (x-dx, y-dy) in visited:
            x, y = x-dx, y-dy
            path.append((x, y))
            break
return steps, list(reversed(path))

在这里，我们从终点开始，沿着搜索路径往回走，直到回到起点。在回溯的过程中，我们依次检查当前节点的八个相邻节点，找到第一个已经被访问的节点，然后以这个节点为起点继续往回走，如此往复，直到回到起点。

以上就是一个基于BFS算法实现的迷宫最短路径求解程序。