Poj 3057 Evacuation

Posted 2020-12-22 rui-4825

Poj 3057 Evacuation

题目大意

对于给定一个图，图中包含 (D)表示门，(X)表示墙，(.) 表示空白处。

要求设定每一个(.) 处有一个人，然后每一秒钟内，智能有一个人通过这个门,求最终所有人都逃出门的最短时间

将时间和门作为一个二元组， 就有时间和门的二元组和人之间的图的关系，求对应的匹配数，如果匹配数满足人的数量，则对应的时间就是即为所求。

solution

将时间和门作为一个二元组， 就有时间和门的二元组和人之间的图的关系，求对应的匹配数，如果匹配数满足人的数量，则对应的时间就是即为所求。

对于每一个人，假设他最快可以在 t 的时间到达门 i，那就把t到最大时间(图的大小) 这些节点建边连到人 j。

如果在这个图上跑二分匹配，当此时的人和门形成匹配就代表人 j 会在时间 t 时从门 i 逃脱。

找最短时间, 不断地枚举点，从该点找增广路。当从时间小的门的点开始枚举，这就代表时间小的门会优先匹配。我们只需看看枚举到哪个时间的门的时候，总匹配数等于人的数量，也是就所有人都被匹配到时，程序就可以结束了。答案就是此时的时间。

#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;
int V, X, Y, dxy[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
char map[13][13];
vector<int> G[50010], dx, dy, px, py;
int match[50005], dist[13][13][13][13];
bool vis[50005];
void add(int u, int v) { G[u].push_back(v), G[v].push_back(u); }
bool find(int v) {
    vis[v] = 1;
    for (int i = 0; i < G[v].size(); i++) {
        int u = G[v][i];
        if (match[u] == -1 || !vis[match[u]] && find(match[u]))
            return match[v] = u, match[u] = v, true;
    }
    return false;
}
void bfs(int x, int y, int d[13][13]) {
    queue<int> qx, qy;
    d[x][y] = 0;
    qx.push(x), qy.push(y);
    while (!qx.empty()) {
        x = qx.front(), qx.pop();
        y = qy.front(), qy.pop();
        for (int k = 0; k < 4; k++) {
            int nx = x + dxy[k][0], ny = y + dxy[k][1];
            if (0 <= nx && nx < X && 0 <= ny && ny < Y && map[nx][ny] == ‘.‘ && d[nx][ny] < 0) {
                d[nx][ny] = d[x][y] + 1;
                qx.push(nx), qy.push(ny);
            }
        }
    }
}
int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        scanf("%d%d", &X, &Y);
        for (int i = 0; i < X; i++) scanf("%s", map[i]);
        int n = X * Y;
        dx.clear(), dy.clear(), px.clear(), py.clear();
        memset(dist, -1, sizeof(dist));
        for (int x = 0; x < X; x++)
            for (int y = 0; y < Y; y++) {
                if (map[x][y] == ‘D‘) {
                    dx.push_back(x), dy.push_back(y), bfs(x, y, dist[x][y]);
                } else if (map[x][y] == ‘.‘)
                    px.push_back(x), py.push_back(y);
            }
        int d = dx.size(), p = px.size();
        V = X * Y * d + p;
        for (int v = 0; v < V; ++v) G[v].clear();
        for (int i = 0; i < d; i++)
            for (int j = 0; j < p; j++)
                if (dist[dx[i]][dy[i]][px[j]][py[j]] >= 0)
                    for (int k = dist[dx[i]][dy[i]][px[j]][py[j]]; k <= n; k++)
                        add((k - 1) * d + i, n * d + j);
        if (p == 0) {
            puts("0");
            continue;
        }
        int res = 0, flag = 1;
        memset(match, -1, sizeof(match));
        for (int v = 0; v < n * d; v++) {
            memset(vis, 0, sizeof(vis));
            if (find(v) && ++res == p) {
                printf("%d
", v / d + 1);
                flag = 0;
                break;
            }
        }
        if(flag)puts("impossible");
    }
}