K - 迷宫问题

定义一个二维数组：

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)

深搜（dfs）：
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stack>
#include <queue>
#include <vector>//动态存储（拓展空间）；
#include <algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
int maze[10][10],s;
struct node
{
    int x,y;
};//存坐标

stack<node> s1;//用栈来存储路径,stack是用来申明空栈；
node ans[100];//存储反过来后路径
void joker(stack<node> a)//栈是反着来的，用这个倒过来
{
    for(int i=(int)a.size()-1; i>=0; i--)//size是队列长度
    {
        ans[i]=a.top();
        a.pop();
    }
}
int go[4][2]= {{1,0},{-1,0},{0,1},{0,-1}};//四个方向
bool vis[10][10];//标记数组
void dfs(int x,int y,int step)
{
    node now;
    now.x=x,now.y=y;
    s1.push(now);//把坐标存进栈中
    if(x==4&&y==4)//当搜索到终点时
    {
        if(step<s)
        {
            s=step;//更新最小的步数
            joker(s1);//翻转栈中的路径
        }

    }

    for(int i=0; i<4; i++)
    {
        int xx=x+go[i][0],yy=y+go[i][1];
        if(xx>=0&&xx<5&&yy>=0&&yy<5&&maze[xx][yy]==0&&vis[xx][yy]==0)//判断是否越界
        {
            vis[xx][yy]=1;//走过的标记为1
            dfs(xx,yy,step+1);//搜索下一层
            vis[xx][yy]=0;//标记回来，以便下次搜索
        }
    }
    s1.pop();//坐标出栈
}
int main()
{
    for(int i=0; i<5; i++)
        for(int j=0; j<5; j++)
            scanf("%d",&maze[i][j]);
    mem(vis,0);//初始化标记数组
    s=0xffffff;//无穷大
    while(s1.size()) s1.pop();//清空栈
    dfs(0,0,0);
    if(s==0xffffff)
        printf("-1\n");
    else
    {
        //printf("%d\n",s);
        for(int i=0; i<=s; i++)
            printf("(%d, %d)\n",ans[i].x,ans[i].y);//输出结果
    }
    return 0;
}
广搜（bfs）：
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stack>
#include <queue>
#include <vector>
#include <algorithm>
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
int map[5][5];//地图
int go[4][2]= {{1,0},{-1,0},{0,-1},{0,1}};//四个方向
int pre[10000];//用来寻找父亲节点
bool vis[10][10];//标记数组
struct node
{
    int x,y,s;
};//存储坐标信息及当前步数
int bfs(int x,int y)
{
    node now,to;//先在的和将要走的
    now.x=x,now.y=y,now.s=0;
    queue<node>q;//创建队列
    vis[x][y]=1;//走过的标记为1
    q.push(now);//加入队首
    while(!q.empty())
    {
        now=q.front();
        if(now.x==4&&now.y==4)return now.s;//满足条件时返回走过的步数
        q.pop();
        for(int i=0; i<4; i++)
        {
            int xx=now.x+go[i][0];
            int yy=now.y+go[i][1];
            if(xx>=0&&yy>=0&&xx<5&&yy<5&&map[xx][yy]==0&&vis[xx][yy]==0)//判断是否越界
            {
                vis[xx][yy]=1;//标记走过的
                to.x=xx,to.y=yy,to.s=now.s+1;
                pre[xx*5+yy]=now.x*5+now.y;//存储坐标，转化成一维形式
                q.push(to);//改变now.x和now.y的值（广搜核心）
            }
        }
    }
    return 0;
}
void myprint(int n)
{
    //printf("pre[%d]=(%d)\n",n,pre[n]);
    if(n==pre[n])return;
    myprint(pre[n]);//寻找父亲节点
    printf("(%d, %d)\n",n/5,n%5);
}//回溯打印路径
int main()
{
    mem(vis,0);
    for(int i=0; i<5; i++)
        for(int j=0; j<5; j++)
            scanf("%d",&map[i][j]);//读入地图
    if(bfs(0,0))
    {
        printf("(0, 0)\n");//先打印0 0
        myprint(4*5+4);//从（4,4）开始回溯
    }
    else
        printf("-1\n");
    return 0;
}