迷宫问题【菜鸟学习日记】

今天学习一个关于栈的经典问题—迷宫问题！

这个问题我们分别用栈和递归两种方法分别来实现一下

还有就是我们分别考虑几种情况去实现和改进优化

1、如果有多条通路
2、找最短路径
3、带环的路径

---

关于问题没有什么可多描述的，就是迷宫，找通路
写迷宫，当然要先有迷宫呀！
先写个迷宫地图

template<size_t N>
class Maze//maze（迷宫）
{
public:
    //1、二维数组传参
    //方法一：
    /*Maze(int maze[][N])
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                _maze[i][j] = maze[i][j];
            }
        }
    }*/

    //方法二：
    Maze(int* maze)
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                _maze[i][j] = maze[i*N + j];
            }
        }
    }
    ...
protected:
    int _maze[N][N];
};

void test()
{
   int maze[10][10] =
    {
        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
        { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 },
        { 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
        { 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
        { 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
        { 1, 1, 0, 0, 0, 1, 1, 1, 1, 1 },
        { 1, 1, 1, 1, 0, 1, 1, 1, 1, 1 },
        { 1, 1, 1, 1, 0, 1, 1, 1, 1, 1 },
        { 1, 1, 1, 1, 0, 1, 1, 1, 1, 1 },
        { 1, 1, 1, 1, 0, 1, 1, 1, 1, 1 },
    };

   Maze<10> mz((int*)maze);//将数组传过去
    ...
}

打印出来看看

好了，地图出来了，就要开始走了，找通路
0为路，1为墙
入口点为（1，0）
这里我们每个点是一个二维坐标，有行和列，所以设置一个结构体变量来放坐标点

struct Pos
{
    int _row;//行
    int _col;//列
}

那我们来考虑一下通路的条件吧
首先我们要检查一下我们下一个走的点，
1、为0，是通路
2、不能超出边界

    bool CheckAccess(Pos pos)//边界检查+点是否合格
    {
        if (pos._row<N&&pos._row>=0
            &&pos._col<N&&pos._col>=0
            &&_maze[pos._row][pos._col] == 0)
        {
            return true;
        }
        return false;
    }

接下来该走了，走过的路，标为2

        bool GetPath(Pos entry)
    {
        Pos cur = entry;

        while (true)
        {
            _maze[cur._row][cur._col] = 2;
            //检查是否已到出口
            if (cur._row == N - 1)
            {
                return true;
            }

            //没有到出口，合法的点
            //探测（上下左右）
            Pos next = cur;
            //上
            next._row -= 1;
            if (CheckAccess(next))
            {
                cur = next;
                continue;
            }
            //下
            next = cur;
            next._row += 1;
            if (CheckAccess(next))
            {
                cur = next;
                continue;
            }
            //左
            next = cur;
            next._col -= 1;
            if (CheckAccess(next))
            {
                cur = next;
                continue;
            }
            //右
            next = cur;
            next._col += 1;
            if (CheckAccess(next))
            {
                cur = next;
                continue;
            }

           return false;
        }
    }

这是最简单的一种，但当迷宫如果有两条通路时，就不行了，而且也无法记录我们走过的路径

所以要进行改进，我们用栈来解决这个问题
首先我们先把入口点压入栈中，然后我们去探测周围的点，某一个有通路就走，没有通路，就出栈，返回上一个点，探测其它方向，一直这样循环，知道出栈空，退回到入口处，把所有通路就都走了一遍

    void GetPath(Pos entry, stack<Pos>& path)
    {
        path.push(entry);

        while (!path.empty())
        {
            Pos cur = path.top();
            _maze[cur._row][cur._col] = 2;

            //上
            Pos next = cur;
            next._row -= 1;
            if (CheckAccess(next))//判是否合格
            {
                cur = next;
                path.push(cur);//合格就入栈
                continue;
            }
            //下
            next = cur;
            next._row += 1;
            if (CheckAccess(next))
            {
                cur = next;
                path.push(cur);
                continue;
            }
            //左
            next = cur;
            next._col -= 1;
            if (CheckAccess(next))
            {
                cur = next;
                path.push(cur);
                continue;
            }
            //右
            next = cur;
            next._col += 1;
            if (CheckAccess(next))
            {
                cur = next;
                path.push(cur);
                continue;
            }

            //回溯
           path.pop();
        }
    }

---

来面我用递归实现

递归实现

递归实现有一个特点，就是递归本身的特性，可以实现天然的回溯，栈是Pop点回溯，而递归本身就可以回溯，当探测周围没有通路，就返回上一级调用，天然回溯到上一个点

   //递归写法（天然回溯）
    bool GetPath(Pos entry, stack<Pos>& path)
    {
        path.push(entry);

        while (!path.empty())
        {
            Pos cur = path.top();
            _maze[cur._row][cur._col] = 2;


            Pos next = cur;
            //上
            next._row -= 1;
            if (CheckAccess(next))//判是否合格
            {
                if (GetPath(next, path))
                {
                    return true;
                }
            }
            //下
            next = cur;
            next._row += 1;
            if (CheckAccess(next))
            {
                if (GetPath(next, path))
                {
                    return true;
                }

            }
            //左
            next = cur;
            next._col -= 1;
            if (CheckAccess(next))
            {
                if (GetPath(next, path))
                {
                    return true;
                }

            }
            //右
            next = cur;
            next._col += 1;
            if (CheckAccess(next))
            {
                if (GetPath(next, path))
                {
                    return true;
                }
            }
            //回溯
            return false;//返回上一层调用，天然回溯
        }
    }

结果和上面一样，走的过程也一样，只是回溯的原理不太一样而已

---

带环迷宫

bool GetPathR(Pos entry, stack<Pos>& path)//(path 路径）//用库里的栈
    {
        path.push(entry);

        while (!path.empty())
        {
            Pos cur = path.top();

            //检查是否已到出口

            //没有到出口，合法的点
            //探测（上下左右）
            Pos next = cur;
            //上
            next._row -= 1;
            if (CheckAccess(cur, next))//判是否合格
            {
                _maze[next._row][next._col] = _maze[cur._row][cur._col] + 1;
                if (GetPathR(next, path))
                {
                    return true;
                }

            }
            //下
            next = cur;
            next._row += 1;
            if (CheckAccess(cur, next))
            {
                _maze[next._row][next._col] = _maze[cur._row][cur._col] + 1;
                if (GetPathR(next, path))
                {
                    return true;
                }

            }
            //左
            next = cur;
            next._col -= 1;
            if (CheckAccess(cur, next))
            {
                _maze[next._row][next._col] = _maze[cur._row][cur._col] + 1;
                if (GetPathR(next, path))
                {
                    return true;
                }

            }
            //右
            next = cur;
            next._col += 1;
            if (CheckAccess(cur, next))
            {
                _maze[next._row][next._col] = _maze[cur._row][cur._col] + 1;
                if (GetPathR(next, path))
                {
                    return true;
                }

            }

            //回溯
            return false;//返回上一层调用
        }
    }