数据结构与算法递归——迷宫找路

Posted 2021-09-06 叁滴水

问题：如上图所示，通过递归算法，计算出从A点到B点的路线。

代码示例

public class MiGongTest
{
   public static void main (String[] args)
   {
      //创建迷宫 1为墙，0为路的像素
      int[][] map = {
            { 1, 1, 1, 1, 1, 1, 1 },
            { 1, 0, 0, 0, 0, 0, 1 },
            { 1, 0, 0, 0, 0, 0, 1 },
            { 1, 1, 1, 1, 0, 0, 1 },
            { 1, 0, 0, 0, 0, 0, 1 },
            { 1, 0, 0, 0, 0, 0, 1 },
            { 1, 0, 0, 0, 0, 0, 1 },
            { 1, 1, 1, 1, 1, 1, 1 }
      };
      MiGongTest.SearchWay(map,1,1);
      System.out.println("打印路线");
      for (int i = 0; i < 8; i++) {
         for (int j = 0; j < 7; j++) {
            System.out.print(map[i][j] + " ");
         }
         System.out.println();
      }
   }
   private static Boolean SearchWay (int[][] map, int x, int y)
   {
      if (map[6][5] == 2)
      {
         return true;
      }
      else {
         if (0 == map[x][y])
         {
            map[x][y] = 2;
            if (SearchWay (map,  x+1, y))
            {
               return true;
            }else if (SearchWay (map, x, y+1))
            {
               return true;
            }else if (SearchWay (map, x-1, y))
            {
               return true;
            }else if (SearchWay (map, x,  y-1))
            {
               return true;
            }else{
               //说明该点是走不通，是死路
               map[x][y] = 3;
               return false;
            }
         }else
         {
            return false;
         }
      }
   }
}

        解题思路：通过二维数组创建迷宫信息。1表示墙，无法通过。0表示可以走，但是还没有走过的点。在每个像素点都进行下、右、上、左进行探路。一直到寻找到对应路线为止。

打印路线：
1 1 1 1 1 1 1
1 2 0 0 0 0 1
1 2 2 2 2 0 1
1 1 1 1 2 0 1
1 0 0 0 2 0 1
1 0 0 0 2 0 1
1 0 0 0 2 2 1
1 1 1 1 1 1 1

其中路线图如下：

        但是这种思路，有一个很大的弊端。如果探路的顺序很重要。如果A在左上角，B在右下角时，必须要下、右开头。这样会会找到最短的路线。如果是上、下、左、右。则路线是这样。

        在每个点位，先判断可否走上、然后上不通之后走下，以此类推。这样就很绕远。

        如此可联想到众多游戏的寻路算法，A*算法。这是一种性能较高的寻路算法。例如在王者、lol等游戏中，点击地图的某个地点，角色可以自动找到最短的路线走过去。这种场景可以通过这种算法实现。

        当然，这里只阐述了如何更好的掌握递归。希望可以帮助大家更好的理解递归。