深度搜索dfs解决迷宫问题

问题描述：

迷宫由n行m列的迷宫组成，其中n、m都小于等于50，每个单元格要么是空地，要么是障碍物，现请你找到一条从起点到终点的最短路径长度

思路分析

    每一个单元格正常而言都有4个方向可走，分别是右下左上，我们可以将每个单元格先按照右下左上的顺序去走，如果右方向不能走（不能走的情况有 边界、障碍、已经访问），则走下，下不可走，则走左、上；

    每个单元格走完以后，要将走过的单元格置为已走，当单元格的位置与终点位置一致时，则代表已经到达终点，此时记录下该条路线的步数，然后回溯去找其他路线，注意，回溯时要将单元格置为未走，此时的单元格代表仍然可以走；

分析一条路线

回溯路线：

最终确定下来三条路线

代码如下：

import java.util.Scanner;
public class Maze {
      /*
        n,m代表迷宫的行数和列数
        endX endY代表目标点的位置
        step代表需要多少步
      */
      static  int n,m, endX,endY,step;
      static  int min = 999999;
      static  int a[][] =new int [51][51];//1表示空地 ， 2表示障碍物
      static  int v[][] =new int [51][51]; //0表现未访问，1表示已访问
      public static void main(String[] args) {
          Scanner scanner = new Scanner(System.in);
          n=scanner.nextInt();//行
          m = scanner.nextInt();//列

          // 为迷宫输入哪些坐标点是空地，哪些坐标点是障碍物
          for (int i = 1; i <= n; i++) {
              for (int j = 1; j <= m; j++) {
                a[i][j] = scanner.nextInt();
              }
           }
          // 输入目标点的x和y
          endX = scanner.nextInt();
          endY= scanner.nextInt();
          // 输入起点x和y
          int startX = scanner.nextInt();
          int startY = scanner.nextInt();
          // 首先将起点置为已访问
          v[startX][startY] =1;
          // 将startX,startY当成当前点，此时走可0步
          dfs(startX,startY,0);
          System.out.println(min);
      }
      static   void dfs( int x, int y,int step){
          // 如果走到目标点，则判断该条路线走过的步数与min比较，小则将step赋给min
          if(x == endX &&y== endY){
              if(step<min){
                min = step;
                return;
              }
          }
          //顺时针
          //要往右走，则需要判断a[x][y+1]是否为障碍物， v[x][y+1]是否已被走过
          if( y+1 <=m &&a[x][y+1] ==1 && v[x][y+1] == 0){
              v[x][y+1] = 1; // 设置该坐标已被走
              dfs(x,y+1,step+1); // 将(x,y+1)作为当前坐标，且步数+1
              v[x][y+1] = 0;  // 回溯后将该坐标设置为未被走
          }

          //要往下走，则需要判断a[x+1][y]是否为障碍物， v[x+1][y]是否已被走过
          if( x+1 <=n &&a[x+1][y] ==1 && v[x+1][y] == 0){
              v[x+1][y] = 1;// 设置该坐标已被走
              dfs(x+1,y,step+1);// 将(x+1,y)作为当前坐标，且步数+1
              v[x+1][y] = 0;// 回溯后将该坐标设置为未被走
          }
          //要往左走，则需要判断a[x-1][y]是否为障碍物， v[x-1][y]是否已被走过
          if( x-1>=1 &&a[x-1][y] ==1 && v[x-1][y] == 0){
              v[x-1][y] = 1;// 设置该坐标已被走
              dfs(x-1,y,step+1);// 将(x-1,y)作为当前坐标，且步数+1
              v[x-1][y] = 0;// 回溯后将该坐标设置为未被走
          }
          //要往上走，则需要判断a[x][y-1]是否为障碍物， v[x][y-1]是否已被走过
          if( y-1>=1 &&a[x][y-1] ==1 && v[x][y-1] == 0){
              v[x][y-1] = 1;// 设置该坐标已被走
              dfs(x,y-1,step+1);// 将(x,y-1)作为当前坐标，且步数+1
              v[x][y-1] = 0;// 回溯后将该坐标设置为未被走
          }

      }
}
输入案例：
5 4
1 1 2 1
1 1 1 1
1 1 2 1
1 2 1 1
1 1 1 2
1 1 4 3

右下左上四个方向上都会操作设置坐标已被走，回溯后都将坐标设置为未被走，重复度太高，我们可以将其优化下

优化代码：

public class Maze {
      /*
          n,m代表迷宫的行数和列数
          endX endY代表目标点的位置
          step代表需要多少步
       */
      static  int n,m, endX,endY,step;
      static  int min = 999999;
      static  int a[][] =new int [51][51];//1表示空地 ， 2表示障碍物
      static  int v[][] =new int [51][51]; //0表现未访问，1表示已访问
      public static void main(String[] args) {
          Scanner scanner = new Scanner(System.in);
          n=scanner.nextInt();//行
          m = scanner.nextInt();//列

          // 为迷宫输入哪些坐标点是空地，哪些坐标点是障碍物
          for (int i = 1; i <= n; i++) {
              for (int j = 1; j <= m; j++) {
                  a[i][j] = scanner.nextInt();
              }
          }
          // 输入目标点的x和y
          endX = scanner.nextInt();
          endY= scanner.nextInt();
          // 输入起点x和y
          int startX = scanner.nextInt();
          int startY = scanner.nextInt();
          // 首先将起点置为已访问
          v[startX][startY] =1;
          // 将startX,startY当成当前点，此时走可0步
          dfs(startX,startY,0);
          System.out.println(min);
      }
      static void dfs( int x, int y,int step){
          // 如果走到目标点，则判断该条路线走过的步数与min比较，小则将step赋给min
          if(x == endX &&y== endY){
              if(step<min){
                  min = step;
                  return;
              }
          }
          //顺时针
          //要往右走，则需要判断a[x][y+1]是否为障碍物， v[x][y+1]是否已被走过
          if( y+1 <=m &&a[x][y+1] ==1 && v[x][y+1] == 0){
              common(x,y+1,step);
          }
          //要往下走，则需要判断a[x+1][y]是否为障碍物， v[x+1][y]是否已被走过
          if( x+1 <=n &&a[x+1][y] ==1 && v[x+1][y] == 0){
              common(x+1,y,step);
          }
          //要往左走，则需要判断a[x-1][y]是否为障碍物， v[x-1][y]是否已被走过
          if( x-1>=1 &&a[x-1][y] ==1 && v[x-1][y] == 0){
              common(x-1,y,step);
          }
          //要往上走，则需要判断a[x][y-1]是否为障碍物， v[x][y-1]是否已被走过
          if( y-1>=1 &&a[x][y-1] ==1 && v[x][y-1] == 0){
              common(x,y-1,step);
          }

      }

      /**
       * 该方法设置坐标已被走，并且 将新的(x,y)作为当前坐标，且步数+1，继续探索
       * 探索完后回溯将当前坐标设置为未被走
       * @param x 坐标x轴
       * @param y 坐标y轴
       * @param step 走过的步数
       */
      public static void common(int x,int y,int step){
          v[x][y] = 1;// 设置该坐标已被走
          dfs(x,y,step+1);// 将(x,y)作为当前坐标，且步数+1
          v[x][y] = 0;// 回溯后将该坐标设置为未被走
      }

}
输入：
5 4
1 1 2 1
1 1 1 1
1 1 2 1
1 2 1 1
1 1 1 2
1 1 4 3
输出：
7

视频分享：