7-1 求解迷宫从入口到出口的一条最短路径

题目详情

求解迷宫从入口到出口的一条最短路径。输入一个迷宫，求从入口通向出口的一条可行最短路径。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n（3<n<=10），则该迷宫横向或纵向尺寸都是n，规定迷宫最外面的一圈是障碍物，迷宫的入口是maze[1][1]，出口是maze[n-2][n-2], 若maze[i][j] = 1代表该位置是障碍物，若maze[i][j] = 0代表该位置是可以行走的空位（0<=i<=n-1, 0<=j<=n-1）。求从入口maze[1][1]到出口maze[n-2][n-2]可以走通的路径。要求迷宫中只允许在水平或上下四个方向的空位上行走，走过的位置不能重复走，规定必须按向右、向下、向左、向上的顺序向前搜索试探，输出先到达出口的最短路径。
如下这样一个迷宫：

对应的二维数组表示：
int maze[10][10]={
{1,1,1,1,1,1,1,1,1,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,0,0,0,1,1,0,0,1},
{1,0,1,1,1,0,0,0,1,1},
{1,0,0,0,1,0,0,0,1,1},
{1,0,1,0,0,0,1,0,0,1},
{1,1,1,1,0,1,1,0,1,1},
{1,0,0,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1}};

输入格式:
输入迷宫大小的整数n, 以及n行和n列的二维数组（数组元素1代表障碍物，0代表空位）。

输出格式:
输出按规定搜索试探顺序先到达出口的首条最短路径，依次输出从入口到出口可行最短路径每个位置的行列下标（i,j），每个位置间用“,”分隔。若没有通路，输出：NO。

输入样例1:

4
1 1 1 1
1 0 1 1
1 0 0 1
1 1 1 1

输出样例1:

(1,1)(2,1)(2,2)

输入样例2:

10
1 1 1 1 1 1 1 1 1 1
1 0 0 1 0 0 0 1 0 1
1 0 0 1 0 0 0 1 0 1
1 0 0 0 0 1 1 0 0 1
1 0 1 1 1 0 0 0 0 1
1 0 0 0 1 0 0 0 0 1
1 0 1 0 0 0 1 0 0 1
1 0 1 1 1 0 1 1 0 1
1 1 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1

输出样例2:

(1,1)(2,1)(3,1)(4,1)(5,1)(5,2)(5,3)(6,3)(6,4)(6,5)(7,5)(8,5)(8,6)(8,7)(8,8)

法1：回溯法、栈

import java.util.Objects;
import java.util.Scanner;
import java.util.Stack;

public class Main {

  static int[][] map;
  static Stack<XY> path;
  static Stack<XY> bestPath;
  static int[][] passed;

  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    path = new Stack<>();
    bestPath = new Stack<>();
    map = new int[n][n];
    passed = new int[map.length][map.length];
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        map[i][j] = scanner.nextInt();
      }
    }
    Main main = new Main();
    XY start = new XY(1, 1);
    XY end = new XY(n-2, n-2);
    if (!start.isAccess()|| !end.isAccess()) {
      System.out.println("NO");
      return;
    }
    main.dfs(start);
    if (bestPath.isEmpty()) {
      System.out.println("NO");
    } else {
      bestPath.forEach(xy -> {
        System.out.print(xy);
      });
    }
  }

  public void dfs(XY xy) {
    xy.setPassed();
    path.push(xy);
    if (xy.isEnd()) {
      if (bestPath.isEmpty() || bestPath.size() >= path.size()) {
        bestPath.removeAll(bestPath);
        bestPath.addAll(path);
      }
      path.pop();
      passed[xy.x][xy.y]=0;
      return;
    }

    //down
    XY down = new XY(xy.x + 1, xy.y);
    if (down.isAccess()) {
      dfs(down);
    }
    //right
    XY right = new XY(xy.x, xy.y + 1);
    if (right.isAccess()) {
      dfs(right);
    }
    //left
    XY left = new XY(xy.x, xy.y - 1);
    if (left.isAccess()) {
      dfs(left);
    }
    //up
    XY up = new XY(xy.x - 1, xy.y);
    if (up.isAccess()) {
      dfs(up);
    }
    path.pop();
    passed[xy.x][xy.y]=0;
  }

}

class XY {

  int x;
  int y;

  public XY() {
  }

  public XY(int x, int y) {
    this.x = x;
    this.y = y;
  }

  boolean isAccess() {
    if (x < 1 || x > Main.map.length - 2 || y < 1 || y > Main.map[0].length - 2
        || Main.map[x][y] == 1 || Main.path.contains(this) || Main.passed[x][y] == 1) {
      return false;
    }
    return true;
  }

  void setPassed() {
    Main.passed[x][y] = 1;
  }


  boolean isEnd() {
    return x == Main.map.length - 2 && x == y;
  }

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

  @Override
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (!(o instanceof XY)) {
      return false;
    }
    XY xy = (XY) o;
    return x == xy.x && y == xy.y;
  }

  @Override
  public int hashCode() {
    return Objects.hash(x, y);
  }
}

法2 队列

待码…