（图 BFS）走迷宫

题目：

　　给一个迷宫，求出从起点到终点的路径。迷宫 src.txt 文件内容如下，第一行是迷宫的行列数，后面行是迷宫，1表示可行走，0表示不可以通过，起点是最左上角，终点是最右下角：

6 5
1 1 0 1 1
1 0 1 1 1
1 0 1 0 0
1 0 1 1 1
1 1 1 0 1
1 1 1 1 1

 

解析：

　　其实就是图的广度优先遍历。

 

代码及运行结果：

#include <iostream>
#include <queue>
#include <fstream>
#include <string>
#include <iomanip>

using std::cout;
using std::endl;
using std::cin;
using std::string;

class Maze
{
public:
    Maze(string file);
    ~Maze();
    void showMaze(void) const;
    void getPath(void);
    void calc(void);
    void showPreNode(void) const;
    void showPath(void) const;

private:
    int m_rows;
    int m_colomns;
    bool** m_pData;        //用bool装迷宫数据

    int** m_preNode;        //记录路径，也就是前一个节点
    bool** m_flag;        //标志是否访问过
    enum { INVALID = -1 };
    
    struct Coord        //定义一个坐标
    {
        int x;
        int y;

        bool operator ==(const Coord& rhs)
        {
            if (this->x == rhs.x && this->y == rhs.y)
                return true;
            return false;
        }
    };

    void initeAboutCalc(void);
    Coord getAssignCoord(const Coord& thisCoord, int num) const;
    void showPathPre(int x, int y) const;
};

Maze::Maze(string file)
{
    std::ifstream fin(file);
    fin >> m_rows >> m_colomns;

    //分配数据区
    m_pData = new bool*[m_rows];
    for (int i = 0; i < m_rows; i++)
        m_pData[i] = new bool[m_colomns];

    //读取数据
    for (int i = 0; i < m_rows; i++)
    {
        for (int j = 0; j < m_colomns; j++)
            fin >> m_pData[i][j];
    }

    //初始化其他
    initeAboutCalc();
}

void Maze::initeAboutCalc(void)
{
    m_preNode = new int*[m_rows];
    m_flag = new bool*[m_rows];
    
    for (int i = 0; i < m_rows; i++)
    {
        m_preNode[i] = new int[m_colomns];
        memset(m_preNode[i], INVALID, m_colomns * sizeof(int));

        m_flag[i] = new bool[m_colomns];
        memset(m_flag[i], false, m_colomns * sizeof(bool));
    }
}

Maze::~Maze()
{
    for (int i = 0; i < m_rows; i++)
        delete[] m_pData[i];

    delete[] m_pData;
}

void Maze::showMaze(void) const
{
    for (int i = 0; i < m_rows; i++)
    {
        for (int j = 0; j < m_colomns; j++)
            cout << m_pData[i][j] << " ";

        cout << endl;
    }
}

void Maze::calc(void)
{
    const Coord START = { 0, 0 };
    const Coord END = { m_rows - 1, m_colomns - 1 };
    const Coord ERROR_COORD = { -1, -1 };

    std::queue<Coord> que;        //二维数组下标放到队列里面去
    m_flag[START.x][START.y] = true;
    que.push(START);        //起点

    while (true)
    {
        Coord thisNode = que.front();
        que.pop();
        if (thisNode == END)
            break;

        //对于这一点的上下左右个点
        for (int i = 0; i < 8; i++)
        {
            Coord coordTemp = getAssignCoord(thisNode, i);
            if (coordTemp == ERROR_COORD || 0 == m_pData[coordTemp.x][coordTemp.y])        //没有这点或者这点是墙
                continue;

            if (!m_flag[coordTemp.x][coordTemp.y])        //没有访问过
            {
                m_flag[coordTemp.x][coordTemp.y] = true;
                m_preNode[coordTemp.x][coordTemp.y] = thisNode.x * m_colomns + thisNode.y;        //注意这里用的不是坐标了，但也可唯一确定一个点
                que.push(coordTemp);
            }
        }
    }
}

Maze::Coord Maze::getAssignCoord(const Coord& thisCoord, int num) const
{
    Coord res = { -1, -1 };        //不合法的
    if (num < 0 || num >= 4)
        return res;

    switch (num)
    {
    case 0:
        {
              if (!thisCoord.x)
                  return res;
              res.x = thisCoord.x - 1;
              res.y = thisCoord.y;
        }
    case 1:
        {
              if (thisCoord.y == m_colomns - 1)
                  return res;
              res.x = thisCoord.x;
              res.y = thisCoord.y +1;
        }
    case 2:
        {
              if (thisCoord.x == m_rows - 1)
                  return res;
              res.x = thisCoord.x + 1;
              res.y = thisCoord.y;
        }
    case 3:
        {
              if (!thisCoord.y)
                  return res;
              res.x = thisCoord.x;
              res.y = thisCoord.y - 1;
        }
    }
    return res;
}

void Maze::showPreNode(void) const
{
    for (int i = 0; i < m_rows; i++)
    {
        for (int j = 0; j < m_colomns; j++)
            cout << std::setw(3) << std::left << m_preNode[i][j];

        cout << endl;
    }
}

void Maze::showPath(void) const
{
    showPathPre(m_rows - 1, m_colomns - 1);
}

void Maze::showPathPre(int x, int y) const
{
    if (0 == x && 0 == y)
    {
        cout << "(" << x << ", " << y << ")" << endl;
    }
    else
    {
        showPathPre(m_preNode[x][y] / m_colomns, m_preNode[x][y] % m_colomns);
        cout << " -> (" << x << ", " << y << ")" << endl;
    }
}

int main(void)
{
    Maze maze("src.txt");
    maze.showMaze();
    cout << endl;
    maze.calc();
    maze.showPreNode();
    cout << endl;
    maze.showPath();
    cin.get();
}