迷宫问题 Maze 4X4 (sloved by backtrack)

Description

---

　

　

　　给定一个N*N的迷宫中，(0,0)为起始点，(N-1,N-1)为目的地，求可通往目的地的多个解

 思路

---

这道题其实就是简单的DFS，一路探索到底，没路就回溯到交叉口。

#include <iostream>
#include <vector>
#include <cstring>
using namespace std;

typedef struct
{
    int x;
    int y;
}pos;

#define N 4  //4*4 maze
#define ENTER_X 0
#define ENTER_Y 0
#define EXIT_X N-1
#define EXIT_Y N-1

int Maze[N][N];
int paths;  //sum of paths
vector<pos> Path;  //svae paths
vector<pos> BestPath; //save min distant path

void InitMaze();
bool MazeTrack(int x,int y); 

int main()
{
    InitMaze();
    int i = 0 , j = 0;
    for(i=0;i<N;i++)
    {    for(j=0;j<N;j++)
            cout << Maze[i][j];
        cout << endl;
    }
    MazeTrack(ENTER_X,ENTER_Y);
    return 0;
}

void InitMaze()
{
    int    a[N][N] = {
        {0,0,0,0},
        {1,0,1,0},
        {1,0,1,0},
        {1,0,1,0}
        };
    memcpy(Maze,a,sizeof(a));
    paths = 0;
}

bool MazeTrack(int x,int y)
{
    bool IsPath = false;
    pos p;
    p.x = x;
    p.y = y;
    //set range of maze's x/y
    if(x<N && x>=0 && y<N && y>=0 && Maze[x][y]==0)
    {
        //make
        Path.push_back(p);
        Maze[x][y] = 1;  //if value is 1,you can't go there
    
        cout << "now,position is("<<x<<","<<y<<")" << endl;
        //terminal
        if(x==EXIT_X && y==EXIT_Y)
        {
            cout << "find a path" << endl;
            paths++;
            IsPath = true;
            vector<pos>::iterator it;
            for(it=Path.begin() ; it!=Path.end() ; it++)
                cout << "("<< it->x <<","<< it->y <<")" << " ";
            cout << endl;
            return IsPath;
        }
        //search  (find forward solutions)
        IsPath = MazeTrack(x-1,y) || MazeTrack(x,y-1) || MazeTrack(x+1,y) || MazeTrack(x,y+1);
        //backtrack
        if(!IsPath)
        {
            Path.pop_back();  
            Maze[x][y] = 0;
        }
        cout << Path.size() << endl;
    }
    //fuction exit
    return IsPath;    
} 

 输出的解：

0000
1010
1010
1010
now,position is(0,0)
now,position is(0,1)
now,position is(1,1)
now,position is(2,1)
now,position is(3,1)
4
3
2
now,position is(0,2)
now,position is(0,3)
now,position is(1,3)
now,position is(2,3)
now,position is(3,3)
find a path
(0,0) (0,1) (0,2) (0,3) (1,3) (2,3) (3,3) 
7
7
7
7
7
7

我是第一次用回溯法，参考了下面的用回溯法解迷宫问题的模板：

 1 using namespace std;
 2 #define N 100  
 3 #define M 100
 4 
 5 typedef struct  
 6 {  
 7        int x;  
 8        int y;
 9 }Point; 
10  
11 vector<Point>solutionPath ;  //存放有解的坐标路径
12 
13 //主函数 x,y默认为起始结点，如(0,0), 得到从起始结点到目的结点的路径。
14 bool hasSolutionFunction( template<typename T>* Matrix , int x, int y)
15 {
16         
17     bool *visited = new bool[M*N]; 
18     memset (visited,0,M*N); //visited 存放每个结点是否被遍历，true为已经遍历过，false为否
19     
20     res =  hasSolutionCore(Matrix , x ,y)
21     cout<<solutionPath<<endl;
22     return res
23 
24 }
25 
26 //深度遍历求解路径的函数
27 bool hasSolutionCore(template<typename T>*  Matrix , int x, int y)
28 {
29     
30     hasSolution = false;
31     Point p = Point(x,y);
32     
33 
34         
35     if (x,y) is terminal  //x,y 已经是终止条件，当求解到这个结点是叶结点或目的地    
36         {
37         solutionPath.push_back(p);
38         return true;
39         }
40 
41     if ((x,y) && visited[x][y]==flase )// x,y是合法结点(具体条件可扩展)，且未被访问过
42     {
43         visited[x][y] = true;
44         solutionPath.push_back(p);
45         
46         hasSolution = hasSolutionCore(Matrix,x-1, y) ||hasSolutionCore(Matrix,x,y-1)||... //如果不是叶结点，则该路径是否有解取决于其他方向的往后求解。
47         
48         // x,y结点以下的所有子路径都无解，则回溯
49         if (!hasSolution)
50         {
51         visited[x][y] = false;
52         solutionPath.pop_back();
53         }
54         
55     }
56     return hasSolution;
57     
58 }