使用numpy和简单的深度优先搜索（DFS）算法来解决矩阵寻路问题

import numpy as np


def find_path(matrix, start, end):
    rows, cols = matrix.shape
    path = []
    visited = set()

    def dfs(i, j):
        if (i, j) not in visited and 0 <= i < rows and 0 <= j < cols and matrix[i][j] != 1:
            visited.add((i, j))
            if (i, j) == end:
                path.append(end)
                return True
            path.append((i, j))
            if dfs(i + 1, j): return True
            if dfs(i - 1, j): return True
            if dfs(i, j + 1): return True
            if dfs(i, j - 1): return True
            path.pop()
        return False

    dfs(*start)
    return path



# 示例使用
matrix = np.array([
    [0, 0, 0, 0, 1],
    [0, 1, 0, 1, 0],
    [0, 1, 0, 1, 0],
    [0, 1, 0, 0, 0],
    [0, 0, 0, 0, 0]
])

start = (0, 0)
end = (4, 4)

path = find_path(matrix, start, end)
print(path)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.

定义了一个find_path函数，它接受一个表示障碍物的矩阵和起点、终点坐标。函数使用深度优先搜索算法寻找一条从起点到终点的路径，并返回一个表示路径的坐标列表。在这个例子中，我们使用了numpy来创建和操作矩阵，并用简单的递归实现了DFS算法。
**【注意】**没有考虑算法优化的问题。可能存在最大递归深度问题！！