深度优先搜索解决迷宫最短路径问题

在之前的文章里我们介绍了深度优先遍历的思想，并且以数组全排列为例子实现了算法编码，本篇我们通过深度优先搜索解决迷宫最短路径问题。用程序实现查询从迷宫入口到终点的最短路径，需要越过障碍物，并且不能超出迷宫界限。

算法图解

假如有如下迷宫，我们需要找到从入口到终点的最短路径，其中标记锁的位置为障碍物不可抵达。

我们先来看第一步可以达到的点有哪些？只有(1,2)和(2,1)。假如我们先往右走来到(2,1)这个点，下一步能到达的点只有(2,2)了，因为(1,3)是障碍物，(1,1)已经走过了，也不能走。但是我们依然没有到达终点，所以得继续往下走，直至无路可走或到达终点为止。注意！并不是到达终点就结束了，因为到达终点只是尝试了一条路，不一定就是最短的。刚才在某些点我们有多个方向可供选择，因此我们需要返回到这些点继续尝试往别的地方走，直到把所有可能都尝试一遍，最后输出最短路径。
现在我们尝试用深度优先搜索来实现这个方法dfs()。首先，dfs方法需要处理的内容包括：先检查当前是否已到达终点处，如果没有到达终点则寻找下一步可以走的地方。为了达到目的，dfs函数需要三个参数，分别对应x,y坐标以及当前步数step。定义如下：

        static void dfs(int x,int y,int step)
        {
            
        }

判断当前是否到达终点很简单，只需要判断和终点坐标是否相同

        static int p ;   //终点y
        static int q ;   //终点坐标y
        static int min;     //当前最短路径步数
        static void dfs(int x,int y,int step)
        {
            //判断是否到达终点
            if (x==p&&y==q)
            {
                //更新最小值
                if (step<min)
                {
                    min = step;
                }
                return; //到达终点则返回
            }
        }

假如没有到达终点，则需要找出下一步可以走的位置。因为有四个方向可以走，我们定义一个方向数组next，如下：

        static int[][] next = new int[][]
        {
            new int[] { 0, 1 }, //向右
            new int[] { 1, 0 }, //向下
            new int[] { 0, -1 },//向左
            new int[] { -1, 0 } //向上
        };

通过这个方向数组，我们可以获得下一步的坐标，这里我们用tx存储下一步横坐标，ty存储下一步纵坐标。

   for (int i = 0; i < next.Length; i++)
   {
        //计算下一步的坐标
        tx = x + next[i][0];
        ty = y + next[i][1];
   }

接下来对下一步的点(tx,ty)进行判断，包括是否越界，是否为障碍物，以及这个点是否已经走过，我们用book数组来记录哪些点已经走过。
如果这个点满足所有要求，就对这个点进行下一步的扩展，即dfs(step+1），一旦进行下一步尝试就意味着步数已经增加了1。

            for (int i = 0; i < next.Length; i++)
            {
                //计算下一步的坐标
                tx = x + next[i][0];
                ty = y + next[i][1];
                //判断是否越界
                if (tx < 1 || tx > n || ty < 1 || ty > m)
                {
                    continue;
                }
                //判断该点是否为障碍物或者已经在路径中
                if (a[tx][ty] == 0 && book[tx][ty] == 0)
                {
                    book[tx][ty] = 1;   //标记这个点已经走过
                    way.Add(string.Format("({0},{1})", tx, ty));    //记录到路径中，用于输出
                    var index = way.Count - 1;
                    dfs(tx, ty, step + 1);  //开始尝试下一步
                    book[tx][ty] = 0;   //尝试结束后取消这个点的标记
                    way.RemoveAt(index);
                }
            }

我们来看一下完整的实现及调用：

    class Program
    {
        static void Main(string[] args)
        {
            int i, j, startx, starty;
            //初始化迷宫信息5*4
            n = 5;
            m = 4;
            for (i = 1; i <= n; i++)
            {
                a[i] = new int[5];
                book[i] = new int[5];
                for (j = 1; j <= m; j++)
                {
                    //(1,3),(3,3),(4,2),(5,4)处为障碍物
                    if ((i == 1 && j == 3) || (i == 3 && j == 3) || (i == 4 && j == 2) || (i == 5 && j == 4))
                    {
                        a[i][j] = 1;
                    }
                    else
                    {
                        a[i][j] = 0;
                    }
                }
            }
            //终点为(4,3)
            p = 4;
            q = 3;
            way.Add("(1,1)");
            book[1][1] = 1;
            dfs(1, 1, 0);   //起点为(1,1)，开始遍历
            Console.WriteLine("最短步数为：" + min);
            Console.ReadKey();
        }
        static int n, m, p, q, min = 99999;
        static int[][] a = new int[6][]; //记录障碍物
        static int[][] book = new int[6][];//记录走过的路径
        static List<string> way = new List<string>();
        static void dfs(int x, int y, int step)
        {
            int[][] next = new int[][]
            {
                new int[] { 0, 1 }, //向右
                new int[] { 1, 0 }, //向下
                new int[] { 0, -1 },//向左
                new int[] { -1, 0 } //向上
            };
            int tx, ty;
            //判断是否到达终点
            if (x == p && y == q)
            {
                //更新最小值
                if (step < min)
                {
                    min = step;
                }
                foreach (var item in way)
                {
                    Console.Write(item + " ");
                }
                Console.WriteLine("到达终点，步数{0}", step);
                return; //到达终点则返回
            }
            for (int i = 0; i < next.Length; i++)
            {
                //计算下一步的坐标
                tx = x + next[i][0];
                ty = y + next[i][1];
                //判断是否越界
                if (tx < 1 || tx > n || ty < 1 || ty > m)
                {
                    continue;
                }
                //判断该点是否为障碍物或者已经在路径中
                if (a[tx][ty] == 0 && book[tx][ty] == 0)
                {
                    book[tx][ty] = 1;   //标记这个点已经走过
                    way.Add(string.Format("({0},{1})", tx, ty));    //记录到路径中，用于输出
                    var index = way.Count - 1;
                    dfs(tx, ty, step + 1);  //开始尝试下一步
                    book[tx][ty] = 0;   //尝试结束后取消这个点的标记
                    way.RemoveAt(index);
                }
            }
            return;
        }

    }

我们在Main方法中按照上面的迷宫图初始化了迷宫，然后从起点(1,1)调用深度优先搜索查找并打印所以通向终点的路径，最后输出最短步数，结果如下图：

至此已经完成了迷宫最短路径的搜索，如果对深度优先遍历思想不太熟悉的可以参考我的上一篇文章：C#深度优先遍历