HDU-ACM“菜鸟先飞”冬训系列赛——第7场 H

Problem H

Problem Description

小边为了寻找梦寐以求的骨头误入一个迷宫,它灵敏的嗅觉告诉它,在迷宫中的某一处有一块完美的骨头.
由于迷宫会在一段时间后关闭,所以小边必须在一定时间找到那块骨头,这样才能有充足的时间来带着骨头离开.
小边在迷宫中可以从当前位置走到相邻的位置,每次移动消耗单位时间,当然,因为小边对骨头的无比执着,它偶尔会使出绝技”狗急跳墙”(一次移动两个单位位置,同样消耗单位时间).使用这个技能的时候,可以翻过一面单位厚度的墙(即第一步移动可以踩在墙上,当然也可以不踩).
hint：使用技能的时候，不用管中间那一步是否可走。
那么小边能够如愿以偿的找到骨头并离开迷宫么?

Input

多组输入
每组输入第一行是四个数m,n(0<m,n<=30),k(0<=k<=30),t(0<=t<=100),分别代表迷宫的长,宽,小边使用”狗急跳墙”的最大次数以及找到骨头的时间限制.
m=n=k=t=0代表输入结束
接下的m行每行有n个字符,‘.’代表地面,’#’代表墙,’@’代表目前小边所处的位置,’X’代表骨头所在的位置

Output

若小边能在规定时间内找到骨头,则输出Yes,否则输出No.
每个输出占一行.

Sample Input

3 3 1 2
@##
#.#
#X#
4 4 1 3
@.#.
#.##
####
##X.
0 0 0 0

Sample Output

Yes
No

这题把我搞死了。
其实直接大力搜就好了，唯一要注意的地方就是：当前走到的位置，如果剩下的使用技能的次数大于曾经走到这里的次数，那么更新。
当然，这里没走到过，也需要更新。
这样，更新次数就不超过30*30*30次（当然事实上远小于这个数量)

 #include <bits/stdc++.h>

 using namespace std;

 #define REP(i,n)                for(int i(0); i <  (n); ++i)
 #define rep(i,a,b)              for(int i(a); i <= (b); ++i)
 #define dec(i,a,b)              for(int i(a); i >= (b); --i)
 #define for_edge(i,x)           for(int i = H[x]; i; i = X[i])

 const int N     =          +       ;
 const int M     =           +       ;
 const int Q     =            +       ;
 const int A     =              +       ;

 const int dx[] = {, , , -};
 const int dy[] = {, , -, };

 const int cx[] = {, , -, , , -, , -};
 const int cy[] = {, , , -, , -, -, };

 struct node{
     int x, y, k, t;
 } st, en;

 char s[Q];
 int n, m, k, t;
 int a[A][A];
 queue <node> q;
 int f[A][A];

 bool check(int x, int y){
     return (x >= )  && (x <= m) && (y >= ) && (y <= n);
 }

 int main(){

     while (~scanf("%d%d%d%d", &m, &n, &k, &t), n + m + k + t){
         memset(a, , sizeof a);
         rep(i, , m){
             scanf("%s", s + );
             rep(j, , n){
                 if (s[j] == '#'){
                     a[i][j] = ;
                 }
                 else{
                     a[i][j] = ;
                     if (s[j] == '@') st.x = i, st.y = j;
                     if (s[j] == 'X') en.x = i, en.y = j;
                 }
             }

         }
         while (!q.empty()) q.pop();
         st.k = k;
         st.t = t;
         q.push(st);
         memset(f, -, sizeof f);
         f[st.x][st.y] = k;
         int ans = ;
         while (!q.empty()){
             node now = q.front(); q.pop();
             if (now.x == en.x && now.y == en.y && now.t >= ){
                 ans = ;
                 break;
             }
             REP(i, ){
                 node nn;
                 nn.x = now.x + dx[i];
                 nn.y = now.y + dy[i];
                 if (check(nn.x, nn.y) && f[nn.x][nn.y] < now.k && !a[nn.x][nn.y]){
                     nn.k = now.k;
                     nn.t = now.t - ;
                     if (nn.t >= ){
                         q.push(nn);
                         f[nn.x][nn.y] = nn.k;
                     }
                 }
             }
             if (now.k > ){
                 REP(i, ){
                     node nn;
                     nn.x = now.x + cx[i];
                     nn.y = now.y + cy[i];
                     if (check(nn.x, nn.y) && f[nn.x][nn.y] < now.k -  && !a[nn.x][nn.y]){
                         nn.k = now.k - ;
                         nn.t = now.t - ;
                         if (nn.t >= ){
                             q.push(nn);
                             f[nn.x][nn.y] = nn.k;
                         }
                     }
                 }
             }
         }
         if (ans) puts("Yes"); else puts("No");
     }
     return ;

 }