hdu 1728 逃离迷宫

最新推荐文章于 2021-03-16 15:52:53 发布

疯狂的橡树

最新推荐文章于 2021-03-16 15:52:53 发布

阅读量884

点赞数

CC 4.0 BY-SA版权

分类专栏：搜索文章标签：算法 C ACM

本文链接：https://blog.youkuaiyun.com/bossup/article/details/8958064

搜索专栏收录该内容

24 篇文章

订阅专栏

本文探讨了迷宫逃脱问题，通过宽度优先搜索算法解决路径寻觅问题，限制了角色转角次数以模拟其方向感。文章详细介绍了算法实现步骤及应用案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

逃离迷宫

Time Limit: 1000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 10002 Accepted Submission(s): 2338

Problem Description

　　给定一个m × n (m行, n列)的迷宫，迷宫中有两个位置，gloria想从迷宫的一个位置走到另外一个位置，当然迷宫中有些地方是空地，gloria可以穿越，有些地方是障碍，她必须绕行，从迷宫的一个位置，只能走到与它相邻的4个位置中,当然在行走过程中，gloria不能走到迷宫外面去。令人头痛的是，gloria是个没什么方向感的人，因此，她在行走过程中，不能转太多弯了，否则她会晕倒的。我们假定给定的两个位置都是空地，初始时，gloria所面向的方向未定，她可以选择4个方向的任何一个出发，而不算成一次转弯。gloria能从一个位置走到另外一个位置吗？

Input

　　第1行为一个整数t (1 ≤ t ≤ 100),表示测试数据的个数，接下来为t组测试数据，每组测试数据中，
　　第1行为两个整数m, n (1 ≤ m, n ≤ 100),分别表示迷宫的行数和列数，接下来m行，每行包括n个字符，其中字符'.'表示该位置为空地，字符'*'表示该位置为障碍，输入数据中只有这两种字符，每组测试数据的最后一行为5个整数k, x ₁, y ₁, x ₂, y ₂ (1 ≤ k ≤ 10, 1 ≤ x ₁, x ₂ ≤ n, 1 ≤ y ₁, y ₂ ≤ m),其中k表示gloria最多能转的弯数，(x ₁, y ₁), (x ₂, y ₂)表示两个位置，其中x ₁，x ₂对应列，y ₁, y ₂对应行。

Output

　　每组测试数据对应为一行，若gloria能从一个位置走到另外一个位置，输出“yes”，否则输出“no”。

Sample Input

  
   2
5 5
...**
*.**.
.....
.....
*....
1 1 1 1 3
5 5
...**
*.**.
.....
.....
*....
2 1 1 1 3

Sample Output

  
   no
yes

Source

“网新恩普杯”杭州电子科技大学程序设计邀请赛

Recommend

lcy

#include <stdio.h>
#include<string.h>

int q[10100],turn[110][110],vist[110][110];
//q存bfs下一取值。turn存到该位置的拐弯数。visit标记到该位置拐弯数是否为最小
int mx[4]= {0,0,1,-1};//存走的四个方向
int my[4]= {1,-1,0,0};
char maps[110][110];
int x,y,dx,dy,bx,by,ex,ey;
int m,n,limit;//limit最多拐弯数
int ok(int x,int y)//判断该位置是否能走
{
    if(maps[x][y]!='*'&&x>=0&&x<m&&y>=0&&y<n)
        return 1;
    return 0;
}
void bfs()
{
    int i,f,r;
    memset(vist,0,sizeof vist);
    vist[bx][by]=1;
    turn[bx][by]=-1;//到任意方向拐弯数为0
    f=r=0;//建一个队列
    q[r++]=bx*n+by;//把位置信息存入队列中。必须从0存起不然会出错
    if(bx==ex&&by==ey)
    {
        printf("yes\n");
        return ;
    }
    while(f<r)//队列不为空
    {
        x=q[f]/n;//还原为位置信息
        y=q[f]%n;
        //printf("%d %d\n",x,y);
        //printf("%d\n",turn[x][y]);
        for(i=0; i<4; i++)
        {
            dx=x+mx[i];//朝一方向走。
            dy=y+my[i];
            while(ok(dx,dy))//一直走到底。直走当然拐弯数最少了
            {
                if(!vist[dx][dy])//该位置为0说明不在（x,y）的直线上
                {               //否则在直线上搜索中已经被置为0
                     vist[dx][dy]=1;//所以从(x,y)到该点必转弯
                    turn[dx][dy]=turn[x][y]+1;//比直走的第一个位置多一个转弯
                    q[r++]=dx*n+dy;//将拐弯数已最小的地方入队
                    //printf("%d %d\n",dx,dy);
                }
               if(dx==ex&&dy==ey&&turn[dx][dy]<=limit)//如果可以走出
               {
                   printf("yes\n");
                   return ;
               }
               //如果vist为1说明该位置拐弯数已经最小不用修改直接走过去
               //而且说明该位置必须转弯
               //这是宽度优先搜索的好处
               //如果有vist为0的说明该次转弯数为其最小值。
               //根据宽度优先的特点。若有更少的转弯数。应该早就搜索到了
               //而不是现在
                dx+=mx[i];
                dy+=my[i];
            }

        }
        f++;
    }
    printf("no\n");
}
int main()
{
    int t,i;

    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&m,&n);
        getchar();
        for(i=0;i<m;i++)
            {
                scanf("%s",maps[i]);//存迷宫
            }
        scanf("%d%d%d%d%d",&limit,&by,&bx,&ey,&ex);//x代表列，y代表行
        //没办法只有颠倒了。。。
        bx-=1,by-=1,ex-=1,ey-=1;
        bfs();
    }
    return 0;
}
/*
2
5 5
...**
*.**.
.....
.....
*....
1 1 1 1 3
5 5
...**
*.**.
.....
.....
*....
2 1 1 1 3
*/