K - 迷宫问题 POJ - 3984

K - 迷宫问题 POJ - 3984 

迷宫问题

定义一个二维数组： 

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

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

测试样例

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

样例输出

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

题意理解：

• 给定一个迷宫，5X5，0代表可以通过，1代表墙不可以通过。
• 求最短路径

解题思路：

这道题就是一个最简单的二维bfs，求最优解而不是解的数量或者全部的解，所以第一反应用bfs。

bfs代码没什么好说的，四个方向，依次入队，再剪剪枝很容易就可以写出代码。

这道题我想说的是输出格式，因为第一遍交告诉我Presentation Error，这个错误是答案是对的但是格式错误,比如多一个空行啊，多一个或者少一个空格什么的。这道题的输出格式没有特别说明，样例输出逗号后面有一个空格。。。

还有就是输出的时候怎么保存路径的问题，我得做法就是打一遍表，然后倒序入栈再出栈输出一遍，十分麻烦，但是我第一反应想到的就是这个方法。

所以我写完ac之后又参考了网上的代码，学习一下。

代码：

我的代码如下：

#include<iostream>
#include<queue>
#include<stack>
#include<cstring>
using namespace std;

int maze[5][5];
int vis[5][5];
int dx[4] = {-1,1,0,0};
int dy[4] = {0,0,-1,1};
struct point {
    int x,y;
    int countn;
};
int check(point p)
{
    if(p.x<0||p.y<0||p.x>=5||p.y>=5||maze[p.x][p.y] == 1)
        return 1;
    return 0;
}
int bfs()
{
    queue<point> q;
    point p;
    p.x = 0;
    p.y = 0;
    p.countn = 1;
    q.push(p);
    while(!q.empty())
    {
        point p1 = q.front();
        q.pop();
        for(int i=0;i<4;i++)
        {
            point p2;
            p2.x = p1.x+dx[i];
            p2.y = p1.y+dy[i];
            p2.countn = p1.countn+1;
            //cout<<p2.countn<<endl;
            if(check(p2))
                continue;
            if(vis[p2.x][p2.y]<0)
                vis[p2.x][p2.y] = p2.countn;
            else
                continue;
            q.push(p2);

        }

    }

}

int main()
{
    stack<point> s;
    memset(vis,-1,sizeof(vis));
    memset(maze,0,sizeof(maze));
    vis[0][0] = 1;

    for(int i=0;i<5;i++)
    {
        for(int j=0;j<5;j++)
        {
            cin>>maze[i][j];
        }
    }
    bfs();
    int num = vis[4][4];
    int i = 4,j = 4;
    while(1)
    {
        if(i==0&&j==0)
            break;
        num--;
        if(vis[i-1][j]==num)
        {
            point p;
            p.x = i-1;
            p.y = j;
            s.push(p);
            i = i-1;
            continue;
        }
        if(vis[i][j-1]==num)
        {
            point p;
            p.x = i;
            p.y = j-1;
            s.push(p);
            j = j-1;
        }

    }
    int length = s.size();
    for(int x = 0;x<length;x++)
    {
        point p;
        p = s.top();
        s.pop();
        cout<<'('<<p.x<<", "<<p.y<<')'<<endl;
    }
    cout<<"(4, 4)"<<endl;
    return 0;
}

标程如下：

#include<stdio.h>
#include<string.h>
#define max 10
int map[max][max];
int vis[max][max];
int dir[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
struct node
{
    int x,y;
}queue[max*max];
int a[max*max];
int b[max*max];
int cnt;
int p[max*max];
void print(int k)
{
    int i;
    int t=p[k];
    if(t==0)
    {
        printf("(0, 0)\n");
        printf("(%d, %d)\n",a[k],b[k]);
    }
    else
    {
        print(t);
        printf("(%d, %d)\n",a[k],b[k]);
    }
}
void bfs(int x,int y)
{
    struct node now,pre;
    queue[0].x=0;
    queue[0].y=0;
    int e=0,h=1;
    p[0]=-1;
    while(e<h)
    {
        pre=queue[e];
        if(pre.x==4&&pre.y==4)
        {
            print(e);
            return;
        }
        int i;
        for(i=0;i<4;i++)
        {
            now.x=pre.x+dir[i][0];
            now.y=pre.y+dir[i][1];
            if(now.x>=0&&now.x<5&&now.y>=0&&now.y<5&&!vis[now.x][now.y]&&map[now.x][now.y]==0)
            {
                vis[now.x][now.y]=1;
                queue[h]=now;
                a[h]=now.x;
                b[h]=now.y;
                p[h]=e;
                h++;
            }
        }
        e++;
    }
    return;
}
int main()
{
    int i,j;
    cnt=0;
    for(i=0;i<5;i++)
    {
        for(j=0;j<5;j++)
        {
            scanf("%d",&map[i][j]);
        }
    }
    memset(vis,0,sizeof(vis));
    bfs(0,0);
    return 0;
}