迷宫最短路径问题(ShortestPath)的求解——利用链式队列

迷宫最短路径问题(ShortestPath)的求解——利用链式队列

注:借助于栈求解迷宫问题时,并不能保证找到一条从迷宫入口到迷宫出口的最短路径。而借助于队列,可以找到从迷宫入口到迷宫出口的最短路径(如果有的话)。在迷宫中寻找最短路径问题在其他领域也存在,例如,在解决电路布线问题时,一种很常用的方法是在布线区域叠上一个网格,该网格把布线区域划分成n*m个方格,就像迷宫一样。从一个方格a的中心点连接到另一个方格b的中心点时,转弯处必须采取直角,如果已经有某条线路经过一个方格,则封锁该方格。希望使用a和b之间的最短路径来作为布线的路径,以便减少信号的延迟。

1. 迷宫问题的提法

  • 迷宫问题是典型的图的搜索问题。
  • 假设一个迷宫,只有一个入口和一个出口。如果从迷宫的入口到达出口,途中不出现行进方向错误,则得到一条最佳路线。
  • 为此,用一个二维数组maze[m][n]来表示迷宫。
    (1)当数组元素maze[i][j]=1 (0≤i≤m-1,1≤j≤n-1),表示该位置是墙壁,不能通行。
    (2)当数组元素maze[i][j]=0 (0≤i≤m-1,1≤j≤n-1),表示该位置是通路,可以通行。
  • 注:数组的第0行、第m-1行,第0列、第n-1列,必须是迷宫的围墙,即上述行列的所有坐标对应的数值必须为1(除了入口和出口两个位置的坐标对应的数值可以为0以外),不能通行。

2. 利用队列求解最短路径的算法原理

  • 先从位置a开始搜索,把从a可到达的相邻方格都标记为1(表示与a的距离为1)。
  • 然后把从标记为1的方格可到达的相邻方格都标记为2(表示与a的距离为2)。
  • 如此继续标记下去,直到到达位置b或者找不到可到达的相邻方格为止。
  • 按照上述搜索过程,当最后到达b时,就可以在b上读出b与a之间的距离。
  • 为了得到a和b之间的最短路径,从b开始,首先移动到一个比b的标号小的相邻位置上,一定存在这样的相邻位置,因为任一个方格上的标号与它相邻方格上的编号都相差1。
  • 设任一时刻在迷宫中的位置[i][j]标记为X,X周围有4个前进方向,它实际是一系列交通路口,如果某一方向是0值,表示该方向有路可通,反之表示该方向已堵死。
  • 为了有效地选择下一位置,可以将从位置[i][j]出发可能的前进方向预先定义在一个表内,按顺时针方向为Right([i][j+1]),Down([i+1][j]),Left([i][j-1]),Up([i-1][j])。
  • (1)前进方向示意图:
    《迷宫最短路径问题(ShortestPath)的求解——利用链式队列》
  • (2)前进方向表:

    Move[q].dirmove[q].amove[q].b
    “N”-10
    “E”01
    “S”10
    “W”0-1

3. 利用队列求解最短路径

3.1 链式队列的类定义及其操作的实现

  • 文件:LinkedQueue.h

    
    #ifndef LINKED_QUEUE_H_
    
    
    #define LINKED_QUEUE_H_
    
    
    
    #include <iostream>
    
    
    using namespace std;
    
    template <class T>
    struct LinkNode         //链表结点类的定义
    {
        T data;             //数据域
        LinkNode<T> *link;  //指针域——后继指针
        //仅初始化指针成员的构造函数
        LinkNode(LinkNode<T>* ptr = NULL){ link = ptr; }
        //初始化数据与指针成员的构造函数
        LinkNode(const T& value, LinkNode<T>* ptr = NULL){ data = value; link = ptr; }
    };
    
    template <class T>
    class LinkedQueue
    {
    public:
        LinkedQueue();                      //构造函数
        ~LinkedQueue();                     //析构函数
    public:
        LinkNode<T>* getHead() const;   //获取队头结点
        bool EnQueue(const T& x);       //新元素x入队
        bool DeQueue(T& x);             //队头元素出队,并将该元素的值保存至x
        bool IsEmpty() const;           //判断队列是否为空
        void MakeEmpty();               //清空队列的内容
    private:
        LinkNode<T> *front; //队头指针,即链头指针
        LinkNode<T> *rear;  //队尾指针,即链尾指针
    };
    
    //构造函数
    template <class T>
    LinkedQueue<T>::LinkedQueue()
    : front(NULL), rear(NULL)
    {
        cout << "$ 执行构造函数" << endl;
    }                       
    
    //析构函数
    template <class T>
    LinkedQueue<T>::~LinkedQueue()
    {
        cout << "$ 执行析构函数" << endl;
        MakeEmpty();
    }   
    
    //获取队头结点
    template <class T>
    LinkNode<T>* LinkedQueue<T>::getHead() const
    {
        return front;
    }
    
    //新元素x入队
    template <class T>
    bool LinkedQueue<T>::EnQueue(const T& x)
    {
        LinkNode<T> *newNode = new LinkNode<T>(x);
        if (NULL == newNode)
        {
            return false;
        }
    
        if (NULL == front)
        {
            front = newNode;
            rear = newNode;
        }
        else
        {
            rear->link = newNode;
            rear = rear->link;
        }
        return true;
    }
    
    //队头元素出队,并将该元素的值保存至x
    template <class T>
    bool LinkedQueue<T>::DeQueue(T& x)
    {
        if (true == IsEmpty())
        {
            return false;
        }
        LinkNode<T> *curNode = front;
        front = front->link;
        x = curNode->data;
        delete curNode;
        return true;
    }
    
    //判断队列是否为空
    template <class T>
    bool LinkedQueue<T>::IsEmpty() const
    {
        return (NULL == front) ? true : false;
    }
    
    //清空队列的内容
    template <class T>
    void LinkedQueue<T>::MakeEmpty()
    {
        LinkNode<T> *curNode = NULL;
        while (NULL != front)           //当链表不为空时,删去链表中所有结点
        {
            curNode = front;            //保存被删结点
            front = curNode->link;      //被删结点的下一个结点成为头结点
            delete curNode;             //从链表上摘下被删结点
        }
    }
    
    
    #endif /* LINKED_QUEUE_H_ */
    

3.2 迷宫的初始化及前进方向表的定义

  • 文件:MazeConfig.h

    
    #ifndef MAZECONFIG_H_
    
    
    #define MAZECONFIG_H_
    
    
    
    #include <iostream>
    
    
    #include <windows.h>
    
    
    using namespace std;
    
    //位置坐标和前进方向序号的三元组结构定义
    struct items
    {
        int x;//位置的x坐标
        int y;//位置的y坐标
    };
    
    //前进方向表的结构定义
    struct offfsets
    {
        int a;//x方向的偏移
        int b;//y方向的偏移
        char *dir;//移动的方向描述
    };
    
    const int m = 9;//迷宫的行数
    const int n = 9;//迷宫的列数
    const int dir_count = 4;//前进方向的总数
    const int pathmark = -1;//迷宫通路的标识值
    
    items entry = { 3, 2 };//迷宫入口网格坐标
    items exitus = { 4, 6 };//迷宫出口网格坐标
    
    //各个方向的偏移表定义
    offfsets moves[dir_count] =
    {
        { 0, 1, "Right" },
        { 1, 0, "Down" },
        { 0, -1, "Left" },
        { -1, 0, "Up" }
    };
    
    //初始化迷宫
    int Maze[m][n] =
    {
        { 1, 1, 1, 1, 1, 1, 1, 1, 1 },
        { 1, 0, 0, 1, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 1, 1, 0, 0, 0, 1 },
        { 1, 0, 0, 0, 0, 1, 0, 0, 1 },
        { 1, 0, 0, 0, 1, 1, 0, 0, 1 },
        { 1, 1, 0, 0, 0, 1, 0, 0, 1 },
        { 1, 1, 1, 1, 0, 0, 0, 0, 1 },
        { 1, 1, 1, 1, 0, 0, 0, 0, 1 },
        { 1, 1, 1, 1, 1, 1, 1, 1, 1 }
    };
    
    //打印迷宫
    void print_maze()
    {
        cout << "======>MazePath" << endl;
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (Maze[i][j] == pathmark)
                {
                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN);
                }
                else
                {
                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY);
                }  
                cout.width(4);  //设置字段宽度为n位
                cout << Maze[i][j];
            }
            cout << endl;
        }
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY);
    }
    
    
    #endif /* MAZECONFIG_H_ */
    

3.3 最短路径的求解算法实现

  • 文件:SeekShortestPath.h

    
    #ifndef SEEKPATH_SHORTEST_H_
    
    
    #define SEEKPATH_SHORTEST_H_
    
    
    
    #include "MazeConfig.h"
    
    
    #include "LinkedQueue.h"
    
    
    void MarkPath()
    {
        int PathLen = Maze[exitus.x][exitus.y];
        cout << "迷宫最短路径长度:" << PathLen << endl;
        items *path = new items[PathLen];
        items cur = exitus;
        items tmp, next;
        for (int j = PathLen - 1; j >= 0; j--)
        {
            tmp = path[j] = cur;
            Maze[tmp.x][tmp.y] = pathmark;
            for (int i = 0; i < dir_count; i++)
            {
                next.x = cur.x + moves[i].a;
                next.y = cur.y + moves[i].b;
                if (Maze[next.x][next.y] == j)
                {
                    break;
                }
            }
            cur = next;
        }
    }
    
    bool SeekShortestPath()
    {
        LinkedQueue<items>* linkedQueue = new LinkedQueue<items>;
        items cur = entry;
        items next = entry;
        Maze[entry.x][entry.y] = 1;
        while ((next.x != exitus.x) || (next.y != exitus.y))
        {
            for (int d = 0; d < dir_count; d++)
            {
                next.x = cur.x + moves[d].a;
                next.y = cur.y + moves[d].b;
                if (Maze[next.x][next.y] == 0)
                {
                    Maze[next.x][next.y] = Maze[cur.x][cur.y] + 1;
                    if ((next.x == exitus.x) && (next.y == exitus.y))
                    {
                        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN);
                        cout << "======>SeekShortestPath Success" << endl;
                        break;
                    }
                    linkedQueue->EnQueue(next);
                }
            }
            if (true == linkedQueue->IsEmpty())
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_INTENSITY | FOREGROUND_RED);
                cout << "======>SeekPath Fail" << endl;
                delete linkedQueue;
                return false;
            }
            linkedQueue->DeQueue(cur);
        }
        MarkPath();
        delete linkedQueue;
        return true;
    }
    
    
    #endif /* SEEKPATH_SHORTEST_H_ */
    

3.4 主函数(main函数)的实现

  • 文件:main.cpp

    
    #include "SeekShortestPath.h"
    
    
    int main(int argc, char* argv[])
    {
        print_maze();
        SeekShortestPath();
        print_maze();
        system("pause");
        return 0;
    }

3.5 迷宫问题求解结果

  • 控制台输出,迷宫通路是绿色高亮显示的路径。
    《迷宫最短路径问题(ShortestPath)的求解——利用链式队列》

参考文献:
[1]《数据结构(用面向对象方法与C++语言描述)(第2版)》殷人昆——第三章
[2] 百度搜索关键字:迷宫问题、队列、广度优先搜索算法

    原文作者:迷宫问题
    原文地址: https://blog.csdn.net/cainv89/article/details/51542440
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞