HDU 3085 Nightmare Ⅱ（噩梦 Ⅱ）

HDU 3085 Nightmare Ⅱ（噩梦 Ⅱ）

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)

 

Problem Description - 题目描述

　　Last night, little erriyue had a horrible nightmare. He dreamed that he and his girl friend were trapped in a big maze separately. More terribly, there are two ghosts in the maze. They will kill the people. Now little erriyue wants to know if he could find his girl friend before the ghosts find them.

　　You may suppose that little erriyue and his girl friend can move in 4 directions. In each second, little erriyue can move 3 steps and his girl friend can move 1 step. The ghosts are evil, every second they will divide into several parts to occupy the grids within 2 steps to them until they occupy the whole maze. You can suppose that at every second the ghosts divide firstly then the little erriyue and his girl friend start to move, and if little erriyue or his girl friend arrive at a grid with a ghost, they will die.

　　Note: the new ghosts also can devide as the original ghost.

昨晚，erriyue经历了一场可怕的噩梦。他梦见自己和女朋友被困在一座大迷宫中。更糟的是，还有两杀人恶鬼环伺其中。现在erriyue想知道自己是否能先于恶鬼找到女朋友。
你可以认为erriyue和他女朋友可以移动4个方向。每回合，erriyue可以移动3步且他女朋友可以移动1步。恶鬼比较溜，可以随意分裂并不断占据2步内的格子，直到覆盖迷宫。每回合鬼先动，人再动，若走到有鬼的格子，卒。
注意：新旧鬼皆能分裂。

 

Input - 输入

　　The input starts with an integer T, means the number of test cases.

　　Each test case starts with a line contains two integers n and m, means the size of the maze. (1<n, m<800)

　　The next n lines describe the maze. Each line contains m characters. The characters may be:

　　　　‘.’ denotes an empty place, all can walk on.

　　　　‘X’ denotes a wall, only people can’t walk on.

　　　　‘M’ denotes little erriyue

　　　　‘G’ denotes the girl friend.

　　　　‘Z’ denotes the ghosts.

　　It is guaranteed that will contain exactly one letter M, one letter G and two letters Z. 

输入开头为整数T，表示测试用例数。
每组测试用例头一行有两个整数n和m，表示迷宫大小。(1<n, m<800)
随后n行迷宫。每行m个字符，表意如下：
‘.’ 空格，谁都能走。
‘X’ 墙，唯鬼能过。
‘M’ erriyue。
‘G’ 女朋友。
‘Z’ 恶鬼。
数据保证仅有一个M，一个G和两个Z。

 

Output - 输出

　　Output a single integer S in one line, denotes erriyue and his girlfriend will meet in the minimum time S if they can meet successfully, or output -1 denotes they failed to meet.

如果erriyue 和女朋友可以在最短时间S成功相遇，则输出整数S在单独一行；否则输出-1。

 

Sample Input - 输入样例

3
5 6
XXXXXX
XZ..ZX
XXXXXX
M.G...
......
5 6
XXXXXX
XZZ..X
XXXXXX
M.....
..G...

10 10
..........
..X.......
..M.X...X.
X.........
.X..X.X.X.
.........X
..XX....X.
X....G...X
...ZX.X...
...Z..X..X

 

 

Sample Output - 输出样例

1
1
-1

 

题解

　　两层BFS（当然双向也可以）

　　人可以等人，人不能穿鬼，鬼比人快1s……

　　然后把两层结果比较一下就行了。

 

代码 C++

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <queue>
#define MX 805
#define INF 0x7F7F7F7F
struct Point {
    int y, x;
}M, G, Z[2], now, nxt;
int data[MX][MX][2], drc[8] = { -1, 0, 1, 0, 0, -1, 0, 1 };
bool isCatch(int y, int x, int tim) {
    return std::min(abs(y - Z[0].y) + abs(x - Z[0].x), abs(y - Z[1].y) + abs(x - Z[1].x)) <= tim * 2;
}
void BFS() {
    int i = 0, j, tim, tmp;
    std::queue<Point> q;
    for (i = 0; i < 2; ++i) {
        i ? q.push(G) : q.push(M);
        while (!q.empty()) {
            now = q.front(); q.pop();
            tim = data[now.y][now.x][i] + 1;
            tmp = i ? tim : (tim + 2) / 3;
            if (isCatch(now.y, now.x, tmp)) continue;
            for (j = 0; j < 8; j += 2) {
                nxt.y = now.y + drc[j]; nxt.x = now.x + drc[j + 1];
                if (isCatch(nxt.y, nxt.x, tmp) || data[nxt.y][nxt.x][i] <= tim) continue;
                data[nxt.y][nxt.x][i] = tim;
                q.push(nxt);
            }
        }
    }
}
int main() {
    char str[MX];
    int t, i, j, n, m, iz, opt, tim;
    scanf("%d", &t);
    while (t--) {
        scanf("%d%d ", &n, &m);
        memset(data, -1, sizeof data); iz = 0;
        for (i = 0; i < n; ++i) {
            gets(str);
            for (j = 0; j < m; ++j) {
                switch (str[j]) {
                    case '.': data[i + 1][j + 1][0] = data[i + 1][j + 1][1] = INF; break;
                    case 'Z': Z[iz].y = i + 1; Z[iz].x = j + 1; ++iz; break;
                    case 'M': M.y = i + 1; M.x = j + 1; break;
                    case 'G': G.y = i + 1; G.x = j + 1; break;
                }
            }
        }
        data[M.y][M.x][1] = data[G.y][G.x][0] = INF;
        data[M.y][M.x][0] = data[G.y][G.x][1] = 0;
        BFS();
        opt = INF;
        for (i = 1; i <= n; ++i) {
            for (j = 1; j <= m; ++j) {
                if ((data[i][j][0] | data[i][j][1]) == -1) continue;
                tim = std::max((data[i][j][0] + 2) / 3, data[i][j][1]);
                opt = std::min(opt, tim);
            }
        }
        opt > MX ? puts("-1") : printf("%d\n", opt);
    }
    return 0;
}