HDU 3533 BFS+优先队列

点击打开链接

题意：给一个题中的图，然后从0 0走到m n，然后有d点能量，问能否走到，走到最少需要多少步，还有k个塔，每个塔有坐标和子弹速度和发射的时间间隔，人可以停可以上下左右走，若被打死就不能走到终点，子弹在穿过另一个塔时就停下来，而且只有在人停在某一个位置时并且这个时间有子弹落在这个坐标则人就死了

思路：对于最少的步数，优先队列比较给力，然后就是怎么走的问题，对于这道题来说，一个点的状态最多为d，因为可以走d的能量，然后就是如何判断会不会被打死，那就直接暴力判断就行了呗，对于当前点就找它的四个方向直到碰到塔后者走出界限为止，然后判断这个塔能否消灭这个人，这就是小处理自己处理就可以了，刚交了个C++跑了9000多ms，光荣的排在杭电这道题的最后一名，然后换了G++倒数第四(/ □ \)

#include <queue>
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3fll;
const int maxn=110;
int n,m,k,d;
int dir[5][2]={{0,1},{0,-1},{1,0},{-1,0},{0,0}};
bool vis[maxn][maxn][1010],posvis[maxn][maxn];
char str[110][110],ch[10];
int T[maxn],V[maxn],X[maxn],Y[maxn],id[maxn][maxn];
struct edge{
    int x,y,step,flag;
    friend bool operator< (edge n1,edge n2)
    {return n1.step>n2.step;}
};
bool judge(int x,int y,int val){
    int ff=0;
    for(int i=0;i<4;i++){
        int flag=0;
        int x1=x,y1=y;
        while(1){
            if(flag) break;
            x1=x1+dir[i][0];
            y1=y1+dir[i][1];
            if(x1<0||x1>n||y1<0||y1>m){
                flag=1;continue;
            }
            if(str[x1][y1]!='.'){
                flag=1;
                if(V[id[x1][y1]]==0) break;
                if(i==0&&str[x1][y1]=='N'){
                    if((y1-y)%V[id[x1][y1]]!=0) break;
                    int lll=(y1-y)/V[id[x1][y1]];
                    for(int j=0;j<=val;j+=T[id[x1][y1]]){
                        if(j+lll==val){
                            ff=1;break;
                        }
                    }
                }
                if(i==1&&str[x1][y1]=='S'){
                    if((y-y1)%V[id[x1][y1]]!=0) break;
                    int lll=(y-y1)/V[id[x1][y1]];
                    for(int j=0;j<=val;j+=T[id[x1][y1]]){
                        if(j+lll==val){
                            ff=1;break;
                        }
                    }
                }
                if(i==2&&str[x1][y1]=='W'){
                    if((x1-x)%V[id[x1][y1]]!=0) break;
                    int lll=(x1-x)/V[id[x1][y1]];
                    for(int j=0;j<=val;j+=T[id[x1][y1]]){
                        if(j+lll==val){
                            ff=1;break;
                        }
                    }
                }
                if(i==3&&str[x1][y1]=='E'){
                    if((x-x1)%V[id[x1][y1]]!=0) break;
                    int lll=(x-x1)/V[id[x1][y1]];
                    for(int j=0;j<=val;j+=T[id[x1][y1]]){
                        if(j+lll==val){
                            ff=1;break;
                        }
                    }
                }
            }
        }
        if(ff) return 1;
    }
    return 0;
}
int bfs(){
    priority_queue<edge>que;
    edge c,ne;
    memset(vis,0,sizeof(vis));
    c.x=0,c.y=0,c.step=0;c.flag=0;
    vis[c.x][c.y][0]=1;
    que.push(c);
    while(!que.empty()){
        c=que.top();que.pop();
        if(c.flag) continue;
        if(c.x==n&&c.y==m) return c.step;
        for(int i=0;i<5;i++){
            int xx=c.x+dir[i][0];
            int yy=c.y+dir[i][1];
            if(xx<0||xx>n||yy<0||yy>m||str[xx][yy]!='.'||c.step==d) continue;
            if(vis[xx][yy][c.step+1]) continue;
            ne.x=xx;ne.y=yy;ne.step=c.step+1;ne.flag=c.flag;
            if(judge(xx,yy,ne.step)) ne.flag=1;
            vis[ne.x][ne.y][ne.step]=1;
            que.push(ne);
        }
    }
    return -1;
}
int main(){
    while(scanf("%d%d%d%d",&m,&n,&k,&d)!=-1){
        memset(posvis,0,sizeof(posvis));
        for(int i=0;i<=n;i++)
            for(int j=0;j<=m;j++)
            str[i][j]='.';
        for(int i=1;i<=k;i++){
            scanf("%s%d%d%d%d",ch,&T[i],&V[i],&X[i],&Y[i]);
            str[Y[i]][X[i]]=ch[0];
            id[Y[i]][X[i]]=i;
        }
        int ans=bfs();
        if(ans==-1) printf("Bad luck!\n");
        else printf("%d\n",ans);
    }
    return 0;
}