迷宫探路问题

目的：找出一条可达的路，有两种方法实现。

第一种：非递归方法。

此方法需用到栈结构，可使用STL，将当前周围有其他未到达过的顶点的顶点压入栈中，保持栈顶一直是当前顶点。

当栈顶顶点周围无可达顶点时，就将该顶点弹出，一直循环到找到目的地或栈空，若到达，则将栈中点全部打印出就是一条路，若栈空，则无路可到达目的地。

1000001000
0100101000
0101101000
1000001100
0110101000
1010010000
0101000000
0100111000
0010001100
0001100111

地图如图，‘1’表示可达，‘0’表示不可达，但需要先将图周围添加一层不可达的点，目的是避免检查下标越界，若不想改变地图，还需另加一个标志矩阵flagmap

int stackrealize(const int row,const int col)
{
    while(!ps.empty()){
        point cur = ps.top();
        int flag = 0;
        for(int i=0;i<8;i++){
            point p = cur+dir[i];
            if(!flagmap[p.x][p.y] && map[p.x][p.y]=='1'){
                flag = 1;
                cur=p;
                flagmap[p.x][p.y] = 1;
                ps.push(cur);
                if(cur.x==row && cur.y==col){
                    cout<<ps<<endl;
                    return 1;
                }
                break;
            }
        }
        if(!flag)ps.pop();
    }
    return 0;
}

这里point是一个结构体类型：

struct point{
    int x,y;
    point(){};
    point(int xx,int yy){x=xx;y=yy;};
    point operator + (point p){
        return point(x+p.x,y+p.y);
    }
}way[MAXN*MAXN];

分析：最后保留在栈里面的都是可达目标点的。

第二种：递归方法。

比较简单，直接粘代码：

int BFS(point &cur,const int row,const int col)
{
    if(cur.x==row && cur.y==col){
        way[len] = cur;
        return 1;
    }
    int flag = 0;
    for(int i=0;i<8;i++){
        point tem = cur + dir[i];
        if(flagmap[tem.x][tem.y]==0 && map[tem.x][tem.y]=='1'){
            flag = 1;
            flagmap[tem.x][tem.y] = 1;
         )  if(BFS(tem,row,col))way[len++] = tem;
            break;
        }
    }
    return flag;
}

需要注意的是，要想打印路径，递归函数就要带返回标志，意思是，如果该点最终在要打印的路上，就返回1，否则返回0（可以看着地图模拟一下）。