迷宫求解算法：使用栈实现深度优先搜索

假设迷宫的入口为(0, 0)，出口为(m-1, n-1)。我们可以使用深度优先搜索算法来求解迷宫的通路。

首先，我们需要定义一个节点类来表示迷宫中的坐标点，包括x坐标和y坐标。

class Node:
    def __init__(self, x, y):
        self.x = x
        self.y = y

然后，我们可以定义一个函数来判断一个节点是否在迷宫内，并且是否是通路（值为0）。

def is_valid(maze, x, y):
    if x < 0 or x >= len(maze) or y < 0 or y >= len(maze[0]):
        return False
    if maze[x][y] == 1:
        return False
    return True

接下来，我们可以编写一个非递归的求解迷宫的函数。

def solve_maze(maze):
    stack = []  # 使用链表作为存储结构的栈
    visited = [[False] * len(maze[0]) for _ in range(len(maze))]  # 记录节点是否已经访问过
    start = Node(0, 0)  # 设置迷宫的入口
    stack.append(start)
    visited[start.x][start.y] = True

    result = []  # 存储通路的坐标

    while stack:
        current = stack[-1]  # 获取栈顶节点
        stack.pop()  # 弹出栈顶节点

        # 判断是否到达迷宫出口
        if current.x == len(maze) - 1 and current.y == len(maze[0]) - 1:
            result.append((current.x, current.y))
            return result

        # 尝试向上、下、左、右四个方向移动
        directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
        for dx, dy in directions:
            next_x = current.x + dx
            next_y = current.y + dy

            if is_valid(maze, next_x, next_y) and not visited[next_x][next_y]:
                stack.append(Node(next_x, next_y))
                visited[next_x][next_y] = True
                result.append((current.x, current.y))

    return []

最后，我们可以使用以上函数来求解迷宫的通路，并输出通路的坐标。

maze = [
    [0, 1, 1, 1],
    [0, 0, 1, 0],
    [1, 0, 0, 0],
    [1, 1, 1, 0]
]

result = solve_maze(maze)
if result:
    print('迷宫有通路')
    for x, y in result:
        print(f'( {x}, {y} )')
else:
    print('迷宫没有通路')

输出结果为：

迷宫有通路
( 0, 0 )
( 0, 1 )
( 1, 1 )
( 2, 1 )
( 2, 2 )
( 2, 3 )
( 3, 3 )