Hubrooooooooooo

Time Limit : 3000/1000ms (Java/Other) Memory Limit : 65535/32768K (Java/Other)

Total Submission(s) : 318 Accepted Submission(s) : 65

Font: Times New Roman | Verdana | Georgia

Font Size: ← →

Problem Description

题目描述：
胡萝卜被藏在一个城堡里，你能帮忙找到它吗？城堡由M*N个方格构成，你可以从你所在的位置向上下左右四个方向移动，但是不能移动出边界，在一些特定的方格里，有能量为Z的加速装置。如果你走到有加速装置的方格，就可以立刻按原有方向移动Z步，直到移动到一个没有加速装置的方格，或者移动到边界为止。
请算出找到胡萝卜最少需要走几步？
注意：因加速装置而移动的格子不计入步数。在空中经过的加速装置没有影响。每个格子最多有一个加速装置。加速装置可以重复使用，每个格子可以走多次。

Input

输入描述：
多组测试用例，处理到文件结尾。
对于每组测试用例：
第一行为两个整数M,N，分别为城堡的行数和列数，3<=M,N<=20。（坐标从1开始计）
第二行为一个非负整数K，表示加速装置的个数。
接下来K行，每行有三个整数X,Y,Z。表示在坐标为X,Y处，加速装置可以帮助他移动Z步。1<=X<=M,1<=Y<=N。
最后两行，分别为你的初始位置和胡萝卜的坐标。输入保证你的位置和胡萝卜的位置都在城堡范围内。

Output

对于每组用例，输出一行，为找到胡萝卜用的最少步数。如果找不到胡萝卜，输出Oh my Hubro QVQ

Sample Input

5 5
4
1 2 2
2 4 1
3 4 5
5 4 1
1 1
5 5

Sample Output

3

Author

cwind

这题刚开始题意理解错了，导致错了很多次。题意给的意思是走到一个有加速装置的地方，然后立即瞬移到t步之后，而我以为是一步一步走，还考虑了中间的加速的装置，WA是理所当然的，后面才知道。。附上AC代码。解法并不难，就是BFS+最短路。

  1 #include <stdio.h>
  2 #include <string.h>
  3 #include <math.h>
  4 #include <queue>
  5 #define INF 100000
  6 using namespace std;
  7
  8 int map[25][25], have_run[25][25], m, n, k;
  9 int dir[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
 10
 11 struct node{
 12     int x, y, step;
 13 }s, e;
 14
 15 int ok(int x, int y, int step){
 16     if(x < 1 || y < 1 || x > m || y > n || step > have_run[x][y])
 17       return 0;
 18     return 1;
 19 }
 20
 21 void bfs(){
 22     queue <node> Q;
 23     node p, q;
 24     p.x = s.x;
 25     p.y = s.y;
 26     p.step = 0;
 27     Q.push(p);
 28     while(!Q.empty()){
 29         q = Q.front();
 30         Q.pop();
 31         node into;
 32         if(q.x == e.x && q.y == e.y){
 33             printf("%d\n", q.step);
 34             return ;
 35         }
 36         for(int i = 0; i < 4; i++){
 37             into.x = q.x + dir[i][0];
 38             into.y = q.y + dir[i][1];
 39             into.step = q.step + 1;
 40             if(ok(into.x, into.y, into.step)){
 41                 int flow = 0;
 42                 if(!map[into.x][into.y]){
 43                     if(into.step <= have_run[into.x][into.y]){
 44                         have_run[into.x][into.y] = into.step;
 45                         Q.push(into);
 46                         continue;
 47                     }
 48                 }
 49                 while(map[into.x][into.y]){
 50                     int tx = map[into.x][into.y] * dir[i][0];
 51                     int ty = map[into.x][into.y] * dir[i][1];
 52                     into.x += tx;
 53                     into.y += ty;
 54                     if(into.x < 1){
 55                         into.x = 1;
 56                         break;
 57                     }
 58                     if(into.x > m){
 59                         into.x = m;
 60                         break;
 61                     }
 62                     if(into.y < 1){
 63                         into.y = 1;
 64                         break;
 65                     }
 66                     if(into.y > n){
 67                         into.y = n;
 68                         break;
 69                     }
 70                     if(into.step <= have_run[into.x][into.y]){
 71                         have_run[into.x][into.y] = into.step;
 72                     }
 73                     else{
 74                         flow = 1;
 75                         break;
 76                     }
 77                 }
 78                 if(flow == 0){
 79                     Q.push(into);
 80                 }
 81             }
 82         }
 83     }
 84     printf("Oh my Hubro QVQ\n");
 85 }
 86
 87 int main(){
 88     while(scanf("%d%d", &m, &n) != EOF){
 89         scanf("%d", &k);
 90         memset(map, 0, sizeof(map));
 91         for(int i = 0; i < 23; i++){
 92             for(int j = 0; j < 23; j++){
 93                 have_run[i][j] = INF;
 94             }
 95         }
 96         for(int i = 0; i < k; i++){
 97             int a, b, c;
 98             scanf("%d%d%d", &a, &b, &c);
 99             map[a][b] = c;
100         }
101         scanf("%d%d%d%d", &s.x, &s.y, &e.x, &e.y);
102         bfs();
103     }
104 }