hdu 5336 XYZ and Drops（模拟十滴水游戏bfs）

题意：

模拟十滴水的游戏，可以百度玩一下这个游戏。
在棋盘上有n个水滴，刚开始时在$(x, y)$有一个爆掉的水滴
向周围4个位置溅射，每个水爆掉之后 就没了，分成4个质量为1的向四面的水滴。
然后其他有n个点，有一些已经存在的水滴，水滴到4以上会爆掉。
当水滴越界就会消失。

问最后存在水滴质量
以及水滴爆掉的时间

解析：

这题不难但是还是调试了很久，太久没敲bfs了，有点生疏了。
对每秒的状态进行bfs，分为两种情况讨论
一个是当前bfs到的点的质量是大于4的，那么就记录下该点爆掉的时间
否则判断当前时刻，要走的点是否已经被访问过，如果该点访问过的时间等于当前时间则无需访问（因为已经访问过了），否则朝着这个方向继续bfs。

$my$ $code$

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 105;
const int dx[] = { 1, 0, -1, 0};
const int dy[] = { 0, 1, 0, -1};
int r, c, n, T;

struct Node {
    int x, y, time, dir;
    Node(int x, int y, int time, int dir)
        : x(x), y(y), time(time), dir(dir) {}
};

struct Answer {
    int a, b;
    Answer() {}
    Answer(int a, int b) : a(a), b(b) {}
} ans[N];

int grid[N][N], id[N][N], crack[N][N];

bool inside(int x, int y) {
    if(x > 0 && x <= r && y > 0 && y <= c)
        return true;
    return false;
}


void bfs(int x, int y) {
    queue<Node> que;

    int nx, ny, time, dir;
    for(int i = 0; i < 4; i++) {   
        nx = x + dx[i];
        ny = y + dy[i];
        if(!inside(nx, ny)) continue;
        que.push(Node(nx, ny, 1, i));
    }

    while(!que.empty()) {
        Node node = que.front();
        que.pop();

        x = node.x;
        y = node.y;
        time = node.time;
        dir = node.dir;

        if(grid[x][y] > 0) { //have drop
            grid[x][y]++;
            if(grid[x][y] > 4) {
                grid[x][y] = 0;
                if(id[x][y] && !crack[x][y]) {
                    crack[x][y] = time;
                    ans[id[x][y]] = Answer(0, time);
                }
                for(int i = 0; i < 4; i++) {
                    nx = x + dx[i];
                    ny = y + dy[i];
                    if(!inside(nx, ny) || time + 1 > T) continue;
                    que.push(Node(nx, ny, time + 1, i));
                }
            }
        }else if(crack[x][y] != time) {
            nx = x + dx[dir];
            ny = y + dy[dir];
            if(!inside(nx, ny) || time + 1 > T) continue;
            que.push(Node(nx, ny, time + 1, dir));
        }
    }

    for(int i = 1; i <= r; i++) {
        for(int j = 1; j <= c; j++) {
            if(id[i][j] && !crack[i][j]) {
                ans[id[i][j]] = Answer(1, grid[i][j]);
            }
        }
    }
}

void init() {
    memset(grid, 0, sizeof(grid));
    memset(id, 0, sizeof(id));
    memset(crack, 0, sizeof(crack));
}

int main() {
    int x, y, size;
    while(scanf("%d%d%d%d", &r, &c, &n, &T) != EOF) {
        init();
        for(int i = 1; i <= n; i++) {
            scanf("%d%d%d", &x, &y, &size);
            grid[x][y] = size;
            id[x][y] = i;
        }
        scanf("%d%d", &x, &y);

        bfs(x, y);
        for(int i = 1; i <= n; i++) {
            printf("%d %d\n", ans[i].a, ans[i].b);
        }
    }
    return 0;
}