迷宫

#include<iostream>
using namespace std;

#include<stack>

#define MAX_ROW 10
#define MAX_COL 10

struct Postion
{
    Postion(int x, int y)
    :_x(x)
    , _y(y) 
    {}

    int _x;
    int _y;
};

class Maze
{
public:
    Maze(int array[][MAX_COL], int _row, int _col)
    {
        for (int i = 0; i < _row; i++)
        {
            for (int j = 0; j < _col; j++)
            {
                _map[i][j] = array[i][j];
            }
        }
    }

    bool IsPass(const Postion &p)
    {
        //走出迷宫
        if (p._x < 0 || p._y < 0 || p._x < MAX_ROW || p._y < MAX_COL)
        {
            return true;
        }

        if (_map[p._x][p._y] == 1)
            return true;
        return false;
    }

    bool PassMaze(Postion p)
    {
        if (p._x < 0 || p._y < 0 || p._x < MAX_ROW || p._y < MAX_COL)
        {
            return true;
        }

        if (!IsPass(p))
            return false;

        stack<Postion> _con;
        _con.push(p);

        while (!_con.empty())
        {
            Postion _cur = _con.top;
            if (_cur._x < 0 || _cur._y < 0 || _cur._x < MAX_ROW || _cur._y < MAX_COL)
            {
                return true;
            }
            _map[_cur._x][_cur._y] = 2;
            Postion next(_cur);                           //

            //left
            next._x -= 1;
            if (IsPass(next))
            {
                _con.push(next);
                continue;
            }
            //right
            next = _cur;
            next._x+= 1;
            if (IsPass(next))
            {
                _con.push(next);
                continue;
            }
            //up
            next = _cur;
            next._y -= 1;
            if (IsPass(next))
            {
                _con.push(next);
                continue;
            }
            //down
            next = _cur;
            next._y += 1;
            if (IsPass(next))
            {
                _con.push(next);
                continue;
            }

            _map[_cur._x][_cur._y] = 3;
            _con.pop();
        }
    }

    void PrintfMaze()
    {
        for (int i = 0; i < MAX_ROW; i++)
        {
            for (int j = 0; j < MAX_COL; j++)
            {
                cout << _map[i][j] << ' ';
            }
            cout << endl;
        }
    }


private:
    int _map[MAX_ROW][MAX_COL];
};

void FunTest()
{
    int mapArr[MAX_ROW][MAX_COL] = {
        { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 1, 1, 0, 0, 0, 0, 0 },
        { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
        { 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 1, 1, 0, 0, 0, 0, 0 },
        { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
        { 0, 1, 1, 1, 0, 0, 0, 0, 0, 0 },
        { 0, 0, 0, 1, 1, 1, 1, 0, 0, 0 },
        { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 } };

    Maze maze(mapArr, MAX_ROW, MAX_COL);
    maze.PassMaze(Postion(9, 6));
    maze.PrintfMaze();
}

int main()
{
    FunTest();
    return 0;
}