【openjudge】迷宫

1792:迷宫

总时间限制: 3000ms 内存限制: 65536kB
描述
一天Extense在森林里探险的时候不小心走入了一个迷宫，迷宫可以看成是由n * n的格点组成，每个格点只有2种状态，.和#，前者表示可以通行后者表示不能通行。同时当Extense处在某个格点时，他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上，Extense想要从点A走到点B，问在不走出迷宫的情况下能不能办到。如果起点或者终点有一个不能通行(为#)，则看成无法办到。
输入
第1行是测试数据的组数k，后面跟着k组输入。每组测试数据的第1行是一个正整数n (1 <= n <= 100)，表示迷宫的规模是n * n的。接下来是一个n * n的矩阵，矩阵中的元素为.或者#。再接下来一行是4个整数ha, la, hb, lb，描述A处在第ha行, 第la列，B处在第hb行, 第lb列。注意到ha, la, hb, lb全部是从0开始计数的。
输出
k行，每行输出对应一个输入。能办到则输出“YES”，否则输出“NO”。
样例输入
2
3
.##
..#
#..
0 0 2 2
5
…..
###.#
..#..
###..
…#.
0 0 4 0

样例输出
YES
NO

方法一：
状态: Wrong Answer

#include
#include
#include
using namespace std;
int f[2000][2000],m,i,j,x2,y2;
 int ha,la,hb,lb;
int head,tail,q[20005],p[20005],x,y,x1,y1,b[20005];
int xx[4]={-1,0,1,0},yy[4]={0,-1,0,1};
int main()
{   
    int l;
    scanf("%d",&l);
    while(l--)//当l用完时，结束执行 
     {
        scanf("%d",&m);
        memset(f,0,sizeof(f));//清空 
        memset(b,0,sizeof(b));//清空 
        memset(p,0,sizeof(p));//清空 
        memset(q,0,sizeof(q));//清空 
        for (i=1;i<=m;i++)
           {
             char c[20000];
             scanf("%s",c);//输入矩阵 
             for(j=1;j<=m;j++)
            {
                if (c[j-1]=='.')
                  f[i][j]=1;
                if (c[j-1]=='#')
                  f[i][j]=0;

            }
           }
        scanf("%d%d%d%d",&ha,&la,&hb,&lb);
        ha++;la++;hb++;lb++;
        head=0;tail=1;p[tail]=ha;q[tail]=la;b[tail]=0;// a 初始位置 
        bool pd=0;
        while (headfor(i=0;i<=3;i++)//上下左右 
             {
                int l=xx[i]+p[head];
                    int r=yy[i]+q[head];
                if (l>0&&l<=m&&r>0&&r<=m&&f[l][r]==1)
                  {
                        f[l][r]=0;
                         tail++;  
                        p[tail]=l; 
                        q[tail]=r; 
                        b[tail]=b[head]+1;
                  }
                if (l==hb&&r==lb)//b到达 
                 {
                     pd=1;
                     break;
                 }
              }
         }
            if (pd==true)
                {
                printf("YES\n");
            }
        if (pd==false)
         {printf("NO\n");} 
     }}

方法二：
状态：input error

#include  
#include  
#include 
int n,m;
int map[150][150],x1,x2,y1,y2,a[51],b[51];
bool cy;
char zsmap[150];
using namespace std; 
int lj(int x,int y,int c)
{
    map[x][y]=c;
    a[c]=x;
    b[c]=y;
    if((x==x2)&&(y==y2)) cy=1;
    else
    {
        if((y!=m)&&(map[x][y+1]==0))    lj(x,y+1,c+1);
        if((!y)&&(x!=n)&&(map[x+1][y]==0))  lj(x+1,y,c+1);
        if((!y)&&(y!=1)&&(map[x][y-1]==0))  lj(x,y-1,c+1);
        if((!y)&&(x!=1)&&(map[x-1][y]==0))  lj(x-1,y,c+1);
    }
}
int main()
{

    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%s",zsmap[i]);
        for(int j=1;j<=n;j++)   
        {
            if(zsmap[j-1]=='#') map[i][j]=0;
            if(zsmap[j-1]=='.') map[i][j]=1;    
        }   
    }
    scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
    cy=0;
    lj(x1,y1,1);
    if(cy) printf("YES");
        else printf("NO");
    return 0;

}

方法三：
状态: Accepted

#include
#include
using namespace std;
char a[101][101];
int t,n,x,y,
fx[5]={0,0,1,0,-1},
fy[5]={0,1,0,-1,0},
rx,ry,cx,cy;
bool sfzd,flag,vis[101][101];
void bfs(int i){
    for(int j=1;j<=4;j++){
        if(a[x+fx[j]][y+fy[j]]=='.'&&!vis[x+fx[j]][y+fy[j]]){
            x+=fx[j];y+=fy[j];
            vis[x][y]=1;
            if(x==cx&&y==cy) {sfzd=true;flag=true;break;}
            else bfs(i+1);
            if(!flag) {x-=fx[j];y-=fy[j];vis[x][y]=0;}
            else break;
        }
    }
}
int main(){
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for(int i=0;ifor(int j=0;j0;
        for(int i=0;ifor(int j=0;jcin>>a[i][j];
        cin>>rx>>ry>>cx>>cy;
        x=rx;y=ry;
        if(a[x][y]=='.')
           bfs(1);
        printf("%s\n",sfzd?"YES":"NO");
        sfzd=false;flag=false;
    }
    return 0;
}

随章附赠：

7084:迷宫问题

总时间限制: 1000ms 内存限制: 65536kB
描述
定义一个二维数组：

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表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。

输入
一个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

样例输出

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

希望的曙光：
状态: Accepted

#include
#include
//动态数组头文件
using namespace std;
struct POINT
{
    int x,y,father;
}que[30];//队列
struct WAY
{
    int x,y;
}FIRST;
int F[4][2]={{1,0},{-1,0},{0,1},{0,-1}},head,tail=1; //向量，队首，队尾
bool maze[6][6]; //迷宫
int main()
{
    for(int i=0;i<5;i++) //输入
        for(int j=0;j<5;j++)
            scanf("%d",&maze[i][j]);
    que[0].x=0,que[0].y=0,que[0].father=-1; //起点，为了father不为空，赋值为-1
    while(head//队列不为空
    {
        for(int i=0;i<4;i++)
        {
            que[tail].father=head;
            que[tail].x=que[head].x+F[i][0]; //改变坐标
            que[tail].y=que[head].y+F[i][1];
            if(que[tail].x<0 || que[tail].x>=5 || que[tail].y<0 || que[tail].y>=5 || maze[que[tail].x][que[tail].y]) continue; //越界或为墙
            if(que[tail].x==4 && que[tail].y==4) //到达终点
            {
                vector vec;
                FIRST.x=que[tail].x,FIRST.y=que[tail].y;
                vec.push_back(FIRST);
                int G=que[tail].father;
                while(1) //反推路径
                {
                    FIRST.x=que[G].x;FIRST.y=que[G].y;
                    vec.push_back(FIRST);
                    if(que[G].x==0 && que[G].y==0) break;
                    G=que[G].father;
                }
                int svec=vec.size();
                for(int i=svec-1;i>=0;i--) //反向输出
                    printf("(%d, %d)\n",vec[i].x,vec[i].y);
                return 0;
            }
            tail++;
        }
        head++;
    }
    return 0;
}