回溯法解决迷宫问题(方法2--栈)

//用栈解决迷宫问题
#include <iostream>
#include <stack>
using namespace std;
const int m=5,p=6;
int mark[m+2][p+2];
int Maze[m+2][p+2];
struct offsets{                       //位置在直角坐标下的偏移
    int a,b;                          //a,b是x,y方向的偏移
    char dir[3];                        //dir是方向
};
offsets Move[8]={{0,-1,"W"},{-1,-1,"NW"},{-1,0,"N"},{-1,1,"NE"},{0,1,"E"},{1,1,"SE"},{1,0,"S"},{1,-1,"SW"}};                    //各个方向的偏移表

struct Items{
    int x,y;
    //char di[3];
 //   char direc[3];
};
void SeekPath(int m,int p)
{
    int i,k,d,g,h;
    stack<Items> st;
    Items tmp;
    tmp.x=1,tmp.y=1;                                             //从(1,1)开始
    st.push(tmp);                                                //将(1,1)位置坐标压入栈中
    while(!st.empty())                                          
    {
        k=tmp.x;d=tmp.y;                                         //k,d用于保存栈顶位置坐标信息,来确定下一个坐标值
        for(i=0;i<8;i++)                                         //八个方向遍历试探
        {
            g=k+Move[i].a;                                        //(g,h)为即将试探的坐标值
            h=d+Move[i].b;

            if(g==m&&h==p)                                       //如果试探的刚好是出口,则将栈中元素输出,输出的是进口到出口的反向路径
            {
                 cout<<g<<" "<<h<<endl;                          //先输出出口坐标
                while(!st.empty()){                              //循环从栈中得到坐标位置,反向输出路径
                tmp=st.top();
                cout<<tmp.x<<" "<<tmp.y<<endl;                  //逆序输出经过的位置坐标
                st.pop();
                }

                return ;                                         //找到出口则函数终止
            }
            if(Maze[g][h]==0&&mark[g][h]==0&&g>=0&&h>=0)         //如果试探的坐标满足条件:不是墙,之前没有试探过,坐标值合理
            {                                                    //则压栈
                mark[g][h]=1;                                    //先将该点标记值记作1,下次不能再试探
                tmp.x=g,tmp.y=h;                                 //tmp保存该点位置坐标信息
                st.push(tmp);                                    //压入tmp到栈中
                k=g;                                             //k,d相应的变成此时的栈顶坐标,来确定下一个试探坐标
                d=h;
                i=0;                                           //i=0很关键,新的栈顶坐标(k,d)试探时,仍然要从8个方向试探
            }
        }
        st.pop();                                              //8个方向试探后都不成功,则退栈,试探失败,路径中往后退一步
        tmp=st.top();                                           //tmp保存当前栈顶元素,即后退一步的当前坐标,循环试探其他位置
    }
    cout<<"无法出去"<<endl;
}

int main()
{

    int i,j;
    mark[1][1]=1;
    for(i=0;i<m+2;i++)
        for(j=0;j<p+2;j++)
        cin>>Maze[i][j];
    SeekPath(m,p);
    return 0;
}
/*
1 1 1 1 1 1 1 1
0 0 0 1 1 1 1 1
1 0 1 0 1 1 0 1
0 1 1 0 1 1 0 1
1 1 1 1 0 0 1 1
1 1 1 0 0 1 0 0
1 1 1 1 1 1 1 1
*/

 

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