实现回溯法求走迷宫

题目是这样：

有一个入口比如坐标（0，0） 迷宫是 8x8 的矩阵，出口是 (7,7)，0 为通过，1 为不通

函数为： find_path_in_maze

思路如下：

每个节点（路径坐标点）都有两个元素 坐标和阻塞的坐标数组

使用栈的思想，将入口入栈，在栈顶循环操作，查找下一个可以走的路径 next_path（四个方向坐标查找，去掉阻塞点，已经走过的节点也为阻塞点），如果不通则将栈顶坐标出栈，继续查找，如果最后栈为空则没有路径到达出口，否则最后如果某个点到达了出口则为通。

代码如下：

#include <stdio.h>
#include <stack>
#include <vector>
#include <iostream>
#define PASS_UP 0
#define STOP_UP 1
#define MAX_COORD 8
#define LOW_LIMIT 0
using namespace std;
//坐标
struct COORD
{
    COORD():x(0),y(0){

    }
    COORD(unsigned int x,unsigned int y)
    {
        this->x = x;
        this->y = y;
    }
    COORD &operator=(const COORD &coord)
    {
        x = coord.x;
        y = coord.y;
        return *this;
    }
    unsigned int x;
    unsigned int y;
};
struct Node
{
    Node(unsigned int x,unsigned int y){
        coord.x = x;
        coord.y = y;
    }
    bool InBlocked(COORD &coord)
    {
        for(unsigned int i=0;i<Blocked.size();i++)
        {
            if(coord.x == Blocked[i].x && coord.y == Blocked[i].y)
            {
                return true;
            }
        }
        return false;
    }
    void AddBlocked(COORD &coord)
    {
        Blocked.push_back(coord);
    }
    COORD coord;
    vector<COORD> Blocked;
};
typedef stack<Node> STACK_COORD;
//从迷宫的入口（固定），找到出口，如果没有出口返回false
//如果有出口则返回true,并打印出路径
int maze_array[8][8]={
    {0,1,0,1,0,0,0,1},
    {0,1,0,1,0,0,0,1},
    {0,0,0,0,0,1,0,0},
    {1,1,1,1,0,0,1,1},
    {1,1,1,1,1,0,1,1},
    {1,1,1,1,1,0,0,1},
    {1,1,1,1,1,1,0,0},
    {0,0,0,0,0,0,0,0}
};
bool IsOKAtCoord(COORD &coord)
{
    return (!(coord.x>=MAX_COORD || coord.x<LOW_LIMIT))&&(!(coord.y>=MAX_COORD || coord.y<LOW_LIMIT));
}
bool next_path(Node &node,COORD &coord)
{
    vector<COORD> vec;
    vec.push_back(COORD(node.coord.x+1,node.coord.y));
    vec.push_back(COORD(node.coord.x-1,node.coord.y));
    vec.push_back(COORD(node.coord.x,node.coord.y+1));
    vec.push_back(COORD(node.coord.x,node.coord.y-1));
    for(int i=0;i<4;i++)
    {
        COORD &tmp = vec[i];
        if(IsOKAtCoord(tmp))
        {
            if(maze_array[tmp.x][tmp.y] == PASS_UP && !node.InBlocked(tmp))
            {
                coord = tmp;
                return true;
            }
        }
    }
    return false;
}
bool IsExit(COORD &coord)
{
    return (coord.x == 7 && coord.y == 7);
}
//x --- 入口的横坐标
//y --- 入口的纵坐标
bool find_path_in_maze(int x,int y,stack<Node> &s)
{
    Node node(x,y);
    s.push(node);
    while(!s.empty())
    {
            Node &curr = s.top();
            if(IsExit(curr.coord))
            {
                return true;
            }
            COORD coord;
            bool b = next_path(curr,coord);
            if(b)
            {
                Node tmp(coord.x,coord.y);
                tmp.AddBlocked(curr.coord);
                s.push(tmp);
            }
            else
            {
                s.pop();
                if(!s.empty())
                {
                    Node & tmp = s.top();
                    tmp.AddBlocked(curr.coord);
                }
            }
    }
    return false;
}
int main()
{
    stack<Node> s;
    bool b = false;
    cout <<"result = " << (b=find_path_in_maze(0,0,s)) << endl;
    if(b)
    {
        deque<COORD> deq;
        while(!s.empty())
        {
            Node &node=s.top();
            deq.push_front(node.coord);
            s.pop();
        }
        for(unsigned int i=0;i<deq.size();i++)
        {
            cout <<"("<< deq[i].x <<","<< deq[i].y << ") ";
        }
    }

}