迷宫问题(MazePath)的求解——利用回溯法(backtracking)

Posted Cainv89

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了迷宫问题(MazePath)的求解——利用回溯法(backtracking)相关的知识,希望对你有一定的参考价值。

迷宫问题(MazePath)的求解——利用回溯法(backtracking)

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. 回溯法的概念

2.1 回溯法的定义

  • 回溯法(backtracking)是一种选优搜索法,又称为试探法,按选优条件向前搜索,以达到目标。

2.2 回溯法的思想

  • 回溯法将问题的候选解按某种顺序逐一枚举和检验。
    (1)当发现当前的候选解不可能是解时,就放弃它而选择下一个候选解。
    (2)如果当前的候选解除了不满足问题规模要求外,其他所有要求都已满足,则扩大当前候选解的规模继续试探。
    (3)如果当前的候选解满足了包括问题规模在内的所有要求,则这个候选解将成为问题的一个解。
  • 注:
    (1)当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯法,而满足回溯条件的某个状态的点称为“回溯点”。
    (2)扩大当前候选解的规模并继续试探的过程叫做向前试探。
    (3)用回溯法求解问题时常常使用递归方法进行试探,或使用栈帮助向前试探和回溯。

3. 用回溯法求解迷宫问题的算法原理

  • 在求解迷宫问题的过程中,当沿某一条路径一步步走向出口但发现进入死胡同走不通时,就回溯一步或多步,寻找其他可走的路径,这就是回溯。
  • 设任一时刻在迷宫中的位置[i][j]标记为X,X周围有8个前进方向,它实际是一系列交通路口,如果某一方向是0值,表示该方向有路可通,反之表示该方向已堵死。
  • 为了有效地选择下一位置,可以将从位置[i][j]出发可能的前进方向预先定义在一个表内,按顺时针方向为N([i-1][j]),NE([i-1][j+1]),E([i][j+1]),SE([i+1][j+1]),S([i+1][j]),SW([i+1][j-1]),W([i][j-1]),NW([i-1][j-1])。
    (1)前进方向示意图:
    这里写图片描述
    (2)前进方向表:

    Move[q].dirmove[q].amove[q].b
    “N”-10
    “NE”-11
    “E”01
    “SE”11
    “S”10
    “SW”1-1
    “W”0-1
    “NW”-1-1

4. 利用递归求解迷宫问题

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

  • 文件:MazeConfig.h

    
    #pragma once
    
    
    
    #include <iostream>
    
    
    #include <windows.h>
    
    
    using namespace std;
    
    //位置坐标和前进方向序号的三元组结构定义
    struct items
    {
        int x;//位置的x坐标
        int y;//位置的y坐标
        int dir;//前进方向的序号
    };
    
    //前进方向表的结构定义
    struct offfsets
    {
        int a;//x方向的偏移
        int b;//y方向的偏移
        char *dir;//移动的方向描述
    };
    
    const int m = 14;//迷宫的行数
    const int n = 17;//迷宫的列数
    const int dir_count = 8;//前进方向的总数
    const int pathmark = 6;//迷宫通路的标识值
    
    static int mark[m][n];//访问标记数组
    
    items entry = { 1, 0, 0 };//迷宫入口网格坐标
    items exitus = { m - 2, n - 1, 0 };//迷宫出口网格坐标
    
    //各个方向的偏移表定义
    offfsets moves[dir_count] =
    {
        { -1, 0, "N" },
        { -1, 1, "NE" },
        { 0, 1, "E" },
        { 1, 1, "SE" },
        { 1, 0, "S" },
        { 1, -1, "SW" },
        { 0, -1, "W" },
        { -1, -1, "NW" }
    };
    
    //初始化迷宫
    int Maze[m][n] =
    {
        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
        { 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1 },
        { 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1 },
        { 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1 },
        { 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1 },
        { 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 },
        { 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1 },
        { 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1 },
        { 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
        { 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1 },
        { 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1 },
        { 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0 },
        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
    };
    
    //初始化访问标记数组
    void init_mark()
    {
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                mark[i][j] = 0;
            }
        }
    }
    
    //打印迷宫
    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 << Maze[i][j] << " ";
            }
            cout << endl;
        }
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY);
    }

4.2 迷宫问题的递归求解算法实现

  • 文件:SeekPath.h

    
    #pragma once
    
    
    
    #include "MazeConfig.h"
    
    
    //从迷宫入口[entry.x][entry.y]开始,寻找通向出口的一条路径。
    //如果找到,则函数返回true。
    //如果没找到,则函数返回false。
    bool SeekPath(items tmp)
    {   
        if ((tmp.x == exitus.x) && (tmp.y == exitus.y))
        {
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN);
            cout << "======>SeekPath Success" << endl;
            return true;//已到达出口,函数返回1。
        }
    
        items next;//下一个网格的位置
        for (int d = 0; d < dir_count; d++)//依次按每一个方向寻找通向出口的路径
        {
            next.x = tmp.x + moves[d].a;
            next.y = tmp.y + moves[d].b;
            if ((Maze[next.x][next.y] == 0) && (mark[next.x][next.y] == 0))
            {
                //下一位置可通,试探该方向
                mark[next.x][next.y] = 1;//标记为已访问过
                if (SeekPath(next) == true)//从此位置递归试探
                {
                    //cout << "(" << nextGrid.x << "," << nextGrid.y << ")," << "Direction:" << moveTable[i].dir << ", ";
                    Maze[next.x][next.y] = pathmark;
                    return true;//试探成功,逆向输出路径坐标
                }
            }
            //回溯,换一个方向再试探通向出口的路径。
        }
    
        if ((tmp.x == entry.x) && (tmp.y == entry.y))
        {
            SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED);
            cout << "======>SeekPath Fail" << endl;
        }
    
        return false;//无可通路到出口,函数返回0。
    }

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

  • 文件:main.cpp

    
    #include "SeekPath.h"
    
    
    int main()
    {
        init_mark();
        print_maze();
        if (SeekPath(entry) == true)
        {
            //cout << "(" << entry.x << "," << entry.y << ")" << endl;
            Maze[entry.x][entry.y] = pathmark;  
        }
        print_maze();
        system("pause");
        return 0;
    }

4.4 迷宫问题求解结果

  • 控制台输出,迷宫通路是绿色高亮显示的路径。
    这里写图片描述

5. 利用栈求解迷宫问题

5.1 链式栈的类定义及其操作的实现

  • 文件:LinkedStack.h

    
    #ifndef LINKED_STACK_H_
    
    
    #define LINKED_STACK_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 LinkedStack
    {
    public:
        LinkedStack();                      //构造函数
        ~LinkedStack();                     //析构函数
    public:
        void Push(const T& x) ;         //新元素x进栈
        bool Pop(T& x);                 //栈顶元素出栈,并将该元素的值保存至x
        LinkNode<T>* getTop() const;    //获取栈顶结点
        bool IsEmpty() const;           //判断栈是否为空
        void MakeEmpty();               //清空栈的内容
    private:
        LinkNode<T> *top;   //栈顶指针,即链头指针
    };
    
    //构造函数
    template <class T>
    LinkedStack<T>::LinkedStack()
    : top(NULL)
    {
        cout << "$ 执行构造函数" << endl;
    }                       
    
    //析构函数
    template <class T>
    LinkedStack<T>::~LinkedStack()
    {
        cout << "$ 执行析构函数" << endl;
        MakeEmpty();
    }   
    
    //新元素x进栈
    template <class T>
    void LinkedStack<T>::Push(const T& x)
    {
        LinkNode<T> *newNode = new LinkNode<T>(x);
        newNode->link = top;
        top = newNode;
    }
    
    //栈顶元素出栈,并将该元素的值保存至x
    template <class T>
    bool LinkedStack<T>::Pop(T& x)
    {
        if (true == IsEmpty())
        {
            return false;
        }
        LinkNode<T> *curNode = top;
        top = top->link;
        x = curNode->data;
        delete curNode;
        return true;
    }
    
    //获取栈顶结点
    template <class T>
    LinkNode<T>* LinkedStack<T>::getTop() const
    {
        return top;
    }
    
    //判断栈是否为空
    template <class T>
    bool LinkedStack<T>::IsEmpty() const
    {
        return (NULL == top) ? true : false;
    }
    
    //清空栈的内容
    template <class T>
    void LinkedStack<T>::MakeEmpty()
    {
        LinkNode<T> *curNode = NULL;
        while (NULL != top)             //当链表不为空时,删去链表中所有结点
        {
            curNode = top;              //保存被删结点
            top = curNode->link;        //被删结点的下一个结点成为头结点
            delete curNode;             //从链表上摘下被删结点
        }
    }
    
    
    #endif /* LINKED_STACK_H_ */
    

5.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坐标
        int dir;//前进方向的序号
    };
    
    //前进方向表的结构定义
    struct offfsets
    {
        int a;//x方向的偏移
        int b;//y方向的偏移
        char *dir;//移动的方向描述
    };
    
    const int m = 14;//迷宫的行数
    const int n = 17;//迷宫的列数
    const int dir_count = 8;//前进方向的总数
    const int pathmark = 6;//迷宫通路的标识值
    
    static int mark[m][n];//访问标记数组
    
    items entry = { 1, 0, 0 };//迷宫入口网格坐标
    items exitus = { m - 2, n - 1, 0 };//迷宫出口网格坐标
    
    //各个方向的偏移表定义
    offfsets moves[dir_count] =
    {
        { -1, 0, "N" },
        { -1, 1, "NE" },
        { 0, 1, "E" },
        { 1, 1, "SE" },
        { 1, 0, "S" },
        { 1, -1, "SW" },
        { 0, -1, "W" },
        { -1, -1, "NW" }
    };
    
    //初始化迷宫
    int Maze[m][n] =
    {
        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
        { 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1 },
        { 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1 },
        { 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1 },
        { 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1 },
        { 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1 },
        { 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1 },
        { 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1 },
        { 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
        { 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1 },
        { 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1 },
        { 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1 },
        { 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0 },
        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }
    };
    
    //初始化访问标记数组
    void init_mark()
    {
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                mark[i][j] = 0;
            }
        }
    }
    
    //打印迷宫
    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 << Maze[i][j] << " ";
            }
            cout << endl;
        }
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY);
    }
    
    
    #endif /* MAZECONFIG_H_ */
    

5.3 迷宫问题的非递归求解算法实现

  • 文件:SeekPath.h

    
    #ifndef SEEKPATH_H_
    
    
    #define SEEKPATH_H_
    
    
    
    #include "MazeConfig.h"
    
    
    #include "LinkedStack.h"
    
    
    template <class T>
    void MarkPath(LinkedStack<T>* linkedStack)
    {
        LinkNode<T> *curNode = linkedStack->getTop();
        while (NULL != curNode)
        {
            items item = curNode->data;
            Maze[item.x][item.y] = pathmark;
            curNode = curNode->link;
        }
    }
    
    //从迷宫入口[entry.x][entry.y]开始,寻找通向出口[m][p]的一条路径。
    bool SeekPath()
    {   
        init_mark();
        LinkedStack<items> *linkedStack = new LinkedStack<items>;   //设置工作栈
        items tmp = entry;  //初始化坐标方向为入口
        items cur, next;
        linkedStack->Push(tmp); //初始化的坐标方向三元组进栈
        while (linkedStack->IsEmpty() == false) //栈不为空时,继续进行搜索
        {
            linkedStack->Pop(tmp);  //退栈
            cur.x = tmp.x; cur.y = tmp.y; cur.dir = tmp.dir;    //当前位置坐标和下一个前进方向的序号
            while (cur.dir < dir_count) //还有移动,继续移动
            {
                next.x = cur.x + moves[cur.dir].a; next.y = cur.y + moves[cur.dir].b; next.dir = 0; //找下一个位置的坐标
                if ((next.x == exitus.x) && (next.y == exitus.y))   //到达出口
                {
                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN);
                    cout << "======>SeekPath Success" << endl;
                    linkedStack->Push(cur);
                    linkedStack->Push(exitus);
                    MarkPath(linkedStack);
                    delete linkedStack;
                    return true;
                }
                if ((Maze[next.x][next.y] == 0) && (mark[next.x][next.y] == 0))
                {
                    mark[next.x][next.y] = 1;//标记为已访问过
                    tmp.x = cur.x; tmp.y = cur.y; tmp.dir = cur.dir;    //记忆已通过位置和前进方向
                    linkedStack->Push(tmp); //进栈
                    cur.x = next.x; cur.y = next.y; cur.dir = next.dir; //移动到下一个网格,在各个方向试探
                }
                else
                {
                    cur.dir++;  //试探下一个方向
                }
            }
        }
    
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED);
        cout << "======>SeekPath Fail" << endl;
        delete linkedStack;
        return false;
    }
    
    
    #endif /* SEEKPATH_H_ */
    

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

  • 文件:main.cpp

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

5.5 迷宫问题求解结果

  • 控制台输出,迷宫通路是绿色高亮显示的路径。
    这里写图片描述

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

以上是关于迷宫问题(MazePath)的求解——利用回溯法(backtracking)的主要内容,如果未能解决你的问题,请参考以下文章

利用栈实现迷宫求解

迷宫问题求解之“穷举+回溯”(转载)

迷宫求解程序的回溯逻辑错误

Java数据结构之回溯算法的递归应用迷宫的路径问题

迷宫问题 --- 回溯法

算法设计-搜索回溯法应用举例