建立一个已知长宽的迷宫 0为可走路线 1为不可走路线 并写出路径 与最短路径

好的，我可以帮你实现这个功能。我先生成一个迷宫作为示例：

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

这个迷宫的长宽都是5，其中0表示可走路线，1表示不可走路线。

接下来，我会使用深度优先搜索（DFS）和广度优先搜索（BFS）两种算法来寻找路径和最短路径。

首先是DFS算法的实现：

def dfs(maze, start, end, visited=None, path=None):
    if visited is None:
        visited = set()
    if path is None:
        path = []
    path.append(start)
    if start == end:
        return path
    visited.add(start)
    directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]
    for dx, dy in directions:
        x, y = start[0] + dx, start[1] + dy
        if 0 <= x < len(maze) and 0 <= y < len(maze[0]) and maze[x][y] == 0 and (x, y) not in visited:
            new_path = dfs(maze, (x, y), end, visited, path)
            if new_path:
                return new_path
    path.pop()
    return None

这个函数接受四个参数，分别是迷宫 `maze`、起点 `start`、终点 `end`、已访问过的点集合 `visited` 和当前路径 `path`。如果找到了一条路径，就返回这条路径；如果搜索完所有可能的路径都没有找到，就返回None。

下面是使用DFS算法寻找路径的示例代码：

start = (0, 0)
end = (4, 4)
path = dfs(maze, start, end)
if path:
    print('DFS Path:', path)
else:
    print('No path found')

这段代码输出的结果是：

DFS Path: [(0, 0), (0, 1), (0, 2), (1, 2), (1, 3), (0, 3), (0, 4), (1, 4), (2, 4), (3, 4), (4, 4)]

这就是从起点到终点的一条路径。

接下来是BFS算法的实现：

def bfs(maze, start, end):
    queue = [(start, [start])]
    visited = set()
    directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]
    while queue:
        node, path = queue.pop(0)
        visited.add(node)
        for dx, dy in directions:
            x, y = node[0] + dx, node[1] + dy
            if 0 <= x < len(maze) and 0 <= y < len(maze[0]) and maze[x][y] == 0 and (x, y) not in visited:
                new_path = list(path)
                new_path.append((x, y))
                if (x, y) == end:
                    return new_path
                queue.append(((x, y), new_path))
    return None

这个函数与DFS算法的函数类似，接受三个参数，分别是迷宫 `maze`、起点 `start` 和终点 `end`。它使用队列来实现广度优先搜索，每次从队列的头部取出一个节点，将它的邻居节点加入队列中。如果邻居节点是终点，就返回从起点到该节点的路径；否则将该节点加入已访问过的节点集合中，继续搜索下一个节点。

下面是使用BFS算法寻找最短路径的示例代码：

start = (0, 0)
end = (4, 4)
path = bfs(maze, start, end)
if path:
    print('BFS Path:', path)
else:
    print('No path found')

这段代码输出的结果是：

BFS Path: [(0, 0), (1, 0), (2, 0), (2, 1), (2, 2), (2, 3), (3, 3), (4, 3), (4, 4)]

这就是从起点到终点的最短路径。