迷宫最短路径

定义一个二维数组： int maze[n][m]; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

int maze[6][7] = {
0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 1, 1, 0,
0, 1, 0, 0, 0, 1, 0,
0, 1, 0, 1, 0, 0, 0,
0, 1, 0, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0, 0,
};

输出：

(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

 

class Point {
  private int x;
  private int y;
  public Point(int x, int y) {
    this.x = x;
    this.y = y;
  }

  public String toString() {
    return "{(" + x + "," + y + ")}";
  }
}

class Main {

  public List<Point> fun(int[][] maze) {
    List<List<Point>> res = new ArrayList<>();
    // 第一步
    //创建一个 ArrayList<Integer> step 记录步数
    List<Point> step = new ArrayList<>();
    int n = maze.length;
    int m = maze[0].length;
    //调用 dfs 函数
    dfs(maze, 0, 0, n, m, step, res);

    // 第三步
    //得到结果 筛选最短路径
    int size = Integer.MAX_VALUE;
    int index = 0;
    for (int i = 0; i < res.size(); i++) {
      if (res.get(i).size() < size) {
        size = res.get(i).size();
        index = i;
      }
    }

    //第三步
    //将最短路径保存并输出
    step = res.get(index);

    return step;
  }


  public void dfs(int[][] maze, int i, int j, int n, int m, List<Point> step, List<List<Point>> res) {
    // 越界 、 有墙 、 已经走过
    if (i < 0 || i >= n || j < 0 || j >= m || maze[i][j] == 1 || maze[i][j] == 2) {
      return;
    }
    //添加当前坐标
    step.add(new Point(i, j));
    //如果到达终点
    if (i == n - 1 && j == m - 1) {
      res.add(new ArrayList<>(step));
    } else {
      //标记为已经走过
      maze[i][j] = 2;
      // 递归
      dfs(maze, i + 1, j, n, m, step, res);
      dfs(maze, i, j + 1, n, m, step, res);
      dfs(maze, i - 1, j, n, m, step, res);
      dfs(maze, i, j - 1, n, m, step, res);
      // 回溯
      maze[i][j] = 0;
    }
    //回溯
    step.remove(step.size() - 1);
  }

}