UVALive 7297 bfs

题意 一个小偷偷到了项链 他想知道自己是否可以逃出去 地图中有一个小偷 一个警察 警察有一条狗 一开始 小偷和警察的移动速度都是1 当警察走到小偷经过过的地方时 警察会有一条狗嗅到小偷的气味并且以2的速度去追 

由于问题问的是 小偷是否必定有方法逃出 所以我们可以看作 有无限个警察从一个点出发去抓小偷 每经过一个点 这个点上就会有一个警察站着

所以会有一个limit来记录警察到达这个点的最短的时间 我们可以想到 小偷到这个点的时间和警察到达这个点的时间的差 就是小偷到这个点之后可以行动的时间(如果他以正确的方式移动 他将会在这个时间之后被之后到达这个点的警察的狗以速度2抓到)

所以 我使用t记录小偷从一开始进行的移动时间 lim记录小偷被追到的时间

可以看出 小偷每到一个点 他都会面对一个会在之后的某个时间正常速度走到这个点的警察 这个警察会在之后的某个时间抓到他 而这个时候 小偷背后还有很多个警察 他们也会在某个时间抓到小偷 所以每到一个点 就把到这个点的警察与小偷背后的最快的警察 两个人追到小偷的时间做对比 保留最快的警察

需要注意的是由于这个图是50*50的(然而即使开一个60*60的数组也并不能通过 需要更大) 所以 如果我们不对状态进行限制(加上类似于vis数组的东西) 会超时 并且涛哥提示我 这个点的lim是由小偷到这个点的t和limit[x][y]共同决定的 所以无论这个vis数组记录的是当前时间还是小偷被抓到的时间亦或是小偷可以移动的时间 都是可以的

本来是用j数组来记录最小时间控制这个点的状态压入的 但是只用小偷到达这个点的是与否记录的话 也是可以通过的 我认为是 在普通的移动bfs里面 由于小偷是没有其他状态的 所以 先到的 更好

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<map>
#include<math.h>
#include<queue>
#include<iostream>
using namespace std;
int n , m;
int limit[550][550];
char mp[600][600];
int j[550][550];
struct node
{
    int t;
    int x,y;
    int lim;
};
int stx,sty;
int px,py;
int dx[4]= {0,0,1,-1};
int dy[4]= {1,-1,0,0};
bool check(int x,int y)
{
    if(x>=1&&x<=n&&y>=1&&y<=m)
    {
        if(mp[x][y]!='X')
        {
            return true;
        }
    }
    return false;
}
void bfs1()
{
    node f;
    f.t=0;
    memset(limit,-1,sizeof(limit));
    f.x=px;
    f.y=py;
    queue<node >q;
    q.push(f);
    limit[f.x][f.y]=0;
    while(!q.empty())
    {
        f=q.front();
        q.pop();
        for(int i =0; i<4; i++)
        {
            node s= f;
            s.x+=dx[i];
            s.y+=dy[i];
            s.t++;
            if(check(s.x,s.y)&&(limit[s.x][s.y]==-1||limit[s.x][s.y]>s.t))
            {
                limit[s.x][s.y]=s.t;
                q.push(s);
            }
        }
    }
}
bool bfs2()
{
    queue<node >q;
    node f;
    f.x=stx;
    f.y=sty;
    f.t=0;
    f.lim=limit[f.x][f.y]*2;
    memset(j,-1,sizeof(j));
    q.push(f);
    while(!q.empty())
    {
        f=q.front();
        q.pop();
        if(mp[f.x][f.y]=='E')
        {
            return true;
        }
        for(int i=0; i<4; i++)
        {
            node s= f;
            s.x+=dx[i];
            s.y+=dy[i];
            s.t++;
            if(check(s.x,s.y))
            {
                if(s.t<limit[s.x][s.y])
                {
                    if(s.t<s.lim)
                    {
                        if(j[s.x][s.y]==-1||j[s.x][s.y]>s.lim)
                        {
                            j[s.x][s.y]=s.lim;
                            int nexlim=limit[s.x][s.y]*2-s.t;
                            s.lim=min(s.lim,nexlim);
                            q.push(s);
                        }
                    }
                }
            }
        }
    }
    return false;
}
int main()
{
    while(cin>>m>>n)
    {
        if(m==0&&n==0)
            break;
        getchar();
        for(int i = 1; i<= n; i++)
        {
            gets(mp[i]+1);
        }
        for(int i = 1; i<= n; i++)
        {
            for(int k = 1; k<= m; k++)
            {
                if(mp[i][k]=='T')
                {
                    stx=i;
                    sty=k;
                }
                if(mp[i][k]=='K')
                {
                    px=i;
                    py=k;
                }
            }
        }
        bfs1();
        if(bfs2())
        {
            printf("KEEP IT\n");
        }
        else
        {
            printf("DROP IT\n");
        }
    }
}

　　

转载于:https://www.cnblogs.com/rayrayrainrain/p/5747454.html