poj3057（*二分图匹配建模）

/*
translation:
    给出一张图，其中'.'代表人，'*'代表墙壁，'D'代表门。每道门在同一时刻只能通过一个人。问能否在
    一定时间内使得所有人离开地图。若能，输出最后一个人的离开时间。若不能输出impossible。
solution:
    二分图匹配
    将不同时刻的门看成是一侧的点。先预处理出所有人到各个门的最短距离。然后就是将门拆点，即拆成不同
    时刻对应的点。将能够在这个时刻到达的人与之相连。通过求最大匹配数来判断是否可行。
note:
    * 将问题从求解型转换成判断型，最后通过最大匹配来判断。
    * 将点的编号和时刻数对应起来的方法。（见注释）
*/
#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <queue>

using namespace std;
const int maxn = 50000;
const int INF = 0x3f3f3f3f;

const int dirx[4] = {0, 0, 1, -1};
const int diry[4] = {1, -1, 0, 0};
typedef pair<int,int> P;

vector<int> G[maxn];
vector<P> door, person;
int match[maxn], n;
bool used[maxn], vis[15][15];
int dist[15][15][15][15], X, Y;
char field[15][15];

void add_edge(int u, int v)
{
    G[u].push_back(v);
    G[v].push_back(u);
}

inline bool inside(int x, int y)
{
    return x >= 0 && x < X && y >= 0 && y < Y;
}

void bfs(int x, int y)
{
    memset(vis, 0, sizeof(vis));
    queue<P> q;
    q.push(make_pair(x, y));
    dist[x][y][x][y] = 0;
    while(!q.empty()) {
        P tmp = q.front();    q.pop();

        for(int dir = 0; dir < 4; dir++) {
            int next_x = tmp.first + dirx[dir];
            int next_y = tmp.second + diry[dir];
            if(inside(next_x, next_y) && dist[x][y][next_x][next_y] < 0 && field[next_x][next_y] == '.') {
                q.push(make_pair(next_x, next_y));
                dist[x][y][next_x][next_y] = dist[x][y][tmp.first][tmp.second] + 1;
            }
        }
    }
}

bool dfs(int v)
{
    used[v] = true;
    for(int i = 0; i < G[v].size(); i++) {
        int u = G[v][i], w = match[u];
        if(w < 0 || !used[w] && dfs(w)) {
            match[u] = v;
            match[v] = u;
            return true;
        }
    }
    return false;
}

void solve()
{
    n = X * Y;
    for(int i = 0; i < X; i++) {
        for(int j = 0; j < Y; j++) {
            if(field[i][j] == '.') {
                person.push_back(make_pair(i, j));
            } else if(field[i][j] == 'D') {
                door.push_back(make_pair(i, j));
                bfs(i, j);
            }
        }
    }

    int d = door.size(), p = person.size();
    for(int i = 0; i < d; i++) {
        for(int j = 0; j < p; j++) {
            int dx = door[i].first, dy = door[i].second;
            int px = person[j].first, py = person[j].second;
            if(dist[dx][dy][px][py] >= 0) {
                for(int k = dist[dx][dy][px][py]; k <= n; k++) {
                    add_edge((k-1)*d+i, n*d+j); //不同时刻的门，对应能够到达该门的人。
                }
            }
        }
    }

    if(!p) {
        printf("0\n");
        return;
    }

    int res = 0;
    memset(match, -1, sizeof(match));
    for(int v = 0; v < n*d; v++) {  //最多有n*d个门。因为最多时刻数是n个单位。
        memset(used, 0, sizeof(used));
        if(match[v] < 0) {
            if(dfs(v)) {
                if(++res == p) {
                    printf("%d\n", v / d + 1);  //因为给门编号时是(k-1)*d+i（见add_edge方法），所以这里求时刻
                    return;                     //就是v/d+1，即可将点的编号和时刻数对应起来。
                }
            }
        }
    }
    printf("impossible\n");
}

int main()
{
    //freopen("in.txt", "r", stdin);
    int T;  scanf("%d", &T);
    while(T--) {
        scanf("%d%d", &X, &Y);
        for(int i = 0; i < maxn; i++)   G[i].clear();
        door.clear();   person.clear();
        memset(dist, -1, sizeof(dist));

        for(int i = 0; i < X; i++)
            scanf("%s", field[i]);


        solve();
    }
    return 0;
}