迷宫问题

Description

定义一个二维数组：

int maze[5][5] = {

 0,1, 0, 0, 0,

 0,1, 0, 1, 0,

 0,0, 0, 0, 0,

 0,1, 1, 1, 0,

 0,0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

Input

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。

Output

左上角到右下角的最短路径，格式如样例所示。

Sample Input

0 1 0 0 0

0 1 0 1 0

0 0 0 0 0

0 1 1 1 0

0 0 0 1 0

Sample Output

(0, 0)

(1, 0)

(2, 0)

(2, 1)

(2, 2)

(2, 3)

(2, 4)

(3, 4)

(4, 4)

分析：这是一道典型的深度优先搜索，需要记录路径，第一次把深搜的代码写出来，记录路径始终是我的一个瓶颈，今天终于突破了。。。。。

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int dx[]={1,0,0,-1};
int dy[]={0,1,-1,0};
struct dot
{
   int x,y;
};
int vis[10][10];                   //标记数组
int mp[10][10];                    //输入的数组
dot path[10];                      //记录路径
inline bool in(dot gx)
{
    if(gx.x>=0&&gx.x<5&&gx.y>=0&&gx.y<5)
        return true;
        return false;
}
int count=0;
bool flag; 
void dfs(int x,int y)           //核心代码
{
    int newx,newy;
    dot p;
    if(x==4&&y==4)
    {

        printf("(0, 0)\n");
        for(int i=0;i<count;i++)
            printf("(%d, %d)\n",path[i].x,path[i].y);
            flag=true;
        return  ;
    }
    for(int i=0;i<4;i++)             
    {
        newx=x+dx[i];
        newy=y+dy[i];
        p.x=newx;
        p.y=newy;
        if(!mp[newx][newy]&&!vis[newx][newy]&&in(p))
        {
            vis[newx][newy]=1;
            path[count++]=p;
            dfs(newx,newy);
            vis[newx][newy]=0;              //回溯的应该把标记数组置为0
              count--;                      //路径也要减去那个
            if(flag)                       //找到出路时停止循环
             return ;
        }

    }
}
int main()
{

   for(int i=0;i<5;i++)
        for(int j=0;j<5;j++)
            cin>>mp[i][j];
            memset(vis,0,sizeof(vis));
            flag=false;
             dfs(0,0);

}

迷宫问题

原文：http://blog.csdn.net/qq_qingtian/article/details/45169353