Escape HDU - 3533

最新推荐文章于 2020-03-17 20:37:00 发布

sunyutian1998

最新推荐文章于 2020-03-17 20:37:00 发布

阅读量336

点赞数

CC 4.0 BY-SA版权

分类专栏：搜索文章标签： BFS hdu

本文链接：https://blog.youkuaiyun.com/sunyutian1998/article/details/78443955

搜索专栏收录该内容

33 篇文章

订阅专栏

本文介绍了一种使用三维数组进行标记，并结合广度优先搜索(BFS)算法解决迷宫穿越问题的方法。通过记录地图上的障碍物及其移动规律，实现了在限定时间内找到从起点到终点的可行路径。

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

点击打开链接

感觉这题不太好写。。

学别人用三维数组标记才过的。。

还有注意bfs时要枚举时间看当前时间下能否到达终点有点类似于dfs的迭代

#include <bits/stdc++.h>
using namespace std;

struct node1
{
    int d;
    int t;
    int v;
    int x;
    int y;
};

struct node2
{
    int x;
    int y;
    int t;
};

node1 gg[110];
queue <node2> que;
bool book[110][110][1010],dth[110][110][1010];
int pre[110][110];
int n,m,k,e,ans;

void calculate();
void bfs();
int judge(int x,int y,int t);

int main()
{
    int i,j;
    char ch[2];
    while(scanf("%d%d%d%d",&n,&m,&k,&e)!=EOF)
    {
        memset(pre,0,sizeof(pre));
        for(i=1;i<=k;i++)
        {
            scanf("%s%d%d%d%d",ch,&gg[i].t,&gg[i].v,&gg[i].x,&gg[i].y);
            if(ch[0]=='W') gg[i].d=0;
            if(ch[0]=='N') gg[i].d=1;
            if(ch[0]=='E') gg[i].d=2;
            if(ch[0]=='S') gg[i].d=3;
            pre[gg[i].x][gg[i].y]=1;
        }
        calculate();
        bfs();
        if(ans==-1) printf("Bad luck!\n");
        else printf("%d\n",ans);
    }
    return 0;
}

void calculate()
{
    int next[4][2]={0,-1,-1,0,0,1,1,0};
    int i,j,jj,tx,ty,flag,xx,yy;

    memset(dth,0,sizeof(dth));

    for(i=1;i<=k;i++)
    {
        for(j=1;j<=e;j++)
        {
            dth[gg[i].x][gg[i].y][j]=1;
            tx=gg[i].x+next[gg[i].d][0]*gg[i].v*j;
            ty=gg[i].y+next[gg[i].d][1]*gg[i].v*j;

            if(0<=tx&&tx<=n&&0<=ty&&ty<=m)
            {
                for(jj=j;jj<=e;jj+=gg[i].t)
                {
                    if(dth[tx][ty][jj]==1) continue;
                    flag=0,xx=gg[i].x,yy=gg[i].y;
                    if(gg[i].d==0)
                    {
                        for(yy=gg[i].y-1;yy>=ty;yy--)
                        {
                            if(pre[xx][yy]==1) break;
                        }
                        if(yy<ty) flag=1;
                    }
                    if(gg[i].d==1)
                    {
                        for(xx=gg[i].x-1;xx>=tx;xx--)
                        {
                            if(pre[xx][yy]==1) break;
                        }
                        if(xx<tx) flag=1;
                    }
                    if(gg[i].d==2)
                    {
                        for(yy=gg[i].y+1;yy<=ty;yy++)
                        {
                            if(pre[xx][yy]==1) break;
                        }
                        if(yy>ty) flag=1;
                    }
                    if(gg[i].d==3)
                    {
                        for(xx=gg[i].x+1;xx<=tx;xx++)
                        {
                            if(pre[xx][yy]==1) break;
                        }
                        if(xx>tx) flag=1;
                    }
                    if(flag==1)
                    {
                        dth[tx][ty][jj]=1;
                    }
                }
            }
        }
    }

    return;
}

void bfs()
{
    node2 cur,tem;
    int next[4][2]={0,-1,-1,0,0,1,1,0};
    int i,cnt;
    while(!que.empty()) que.pop();
    memset(book,0,sizeof(book));

    tem.x=0,tem.y=0,tem.t=0;
    if(judge(tem.x,tem.y,tem.t))
    {
        que.push(tem);
    }
    ans=-1,cnt=0;

    while(1)
    {
        cnt++;
        if(que.empty()||cnt>e)
        {
            return;
        }
        while(!que.empty())
        {
            cur=que.front();
            if(cur.t>=cnt) break;
            que.pop();
            cur.t=cnt;
            if(judge(cur.x,cur.y,cnt))
            {
                que.push(cur);
            }
            for(i=0;i<4;i++)
            {
                tem.x=cur.x+next[i][0];
                tem.y=cur.y+next[i][1];
                if(judge(tem.x,tem.y,cnt))
                {
                    if(tem.x==n&&tem.y==m)
                    {
                        ans=cnt;
                        return;
                    }
                    que.push(tem);
                }
            }
        }
    }

    return;
}

int judge(int x,int y,int t)
{
    if(0<=x&&x<=n&&0<=y&&y<=m&&!dth[x][y][t]&&!book[x][y][t])
    {
        book[x][y][t]=1;
        return 1;
    }
    else return 0;
}