POJ 3057 Evacuation【二分+最短路+最大流】

POJ 3057 Evacuation
题意：一幅迷宫图’.’为空格，’D’为门，’#’为墙；现在每个空格处有一人，且每个时刻每个门只能出去一人；当走到门时为离开房间；求所有人撤离的最短时间，否则impossible；
一个迷宫，’.’表示人，’D’表示门(只出现在迷宫四周)，’X’表示墙(迷宫内和边缘都有)，迷宫内起火了，里面内的人需要向外跑。一秒移动一格，一个门每秒只能出一个人，问最后一个人逃离迷宫所花最少时间？
分析：
如果门没有限制人数的话，就最短路裸题了。由于所求时间是最小化的，这就想到了二分里面的最小化最大值。但是二分搜索中给定一个时间，怎么判断是否满足题意呢？这乎是一种匹配问题，也就是一个人从哪个门出，以及什么时间出？从哪个门出并不重要，时间才是二分后所要求的。问题转化为人和时间的匹配，这就抽象成二分图最大匹配了(我用网络流解得)。
BFS先预处理每个人到所有门的最近距离，源点连向人权值为1，人连向时间点(1~mid)权值为1，时间点连向汇点权值为门的数量(表示每时刻逃出的人数)。人连向时刻的时候，加边时注意有的时刻人出不去，能出去的最小时间就是之前BFS预处理出的最短距离，问题可解。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
typedef long long LL;
using namespace std;

const int MAXN = 1e3 + 5;
const int INF = 0x3f3f3f3f;
int head[MAXN], dist[MAXN], vis[MAXN], cur[MAXN];
char ma[15][15];
int top = 0;

struct Edge {
    int to, cap, flow, next;
}edge[MAXN * 100];

void init() {
    top = 0;
    memset(head, -1, sizeof(head));
    memset(vis, 0, sizeof(vis));
}

void addedge(int a, int b, int c) {
    Edge E1 = {b, c, 0, head[a]};
    edge[top] = E1;
    head[a] = top++;
    Edge E2 = {a, 0, 0, head[b]};
    edge[top] = E2;
    head[b] = top++;
}

bool BFS(int st, int ed) {
    memset(dist, -1, sizeof(dist));
    memset(vis, 0, sizeof(vis));
    queue<int> que;
    que.push(st);
    vis[st] = 1;
    dist[st] = 0;
    while(!que.empty()) {
        int u = que.front();
        que.pop();
        for(int i = head[u]; i != -1; i = edge[i].next) {
            Edge E = edge[i];
            if(!vis[E.to] && E.cap > E.flow) {
                dist[E.to] = dist[u] + 1;
                vis[E.to] = 1;
                if(E.to == ed) return true;
                que.push(E.to);
            }
        }
    }
    return false;
}

int DFS(int x, int a, int ed) {
    if(x == ed || a == 0) return a;
    int flow = 0, f;
    for(int& i = cur[x]; i != -1; i = edge[i].next) {
        Edge& E = edge[i];
        if(dist[E.to] == dist[x] + 1 && (f = DFS(E.to, min(a, E.cap - E.flow), ed)) > 0) {
            E.flow += f;
            edge[i^1].flow -= f;
            flow += f;
            a -= f;
            if(a == 0) break;
        }
    }
    return flow;
}

int Maxflow(int st, int ed) {
    int flow = 0;
    while(BFS(st, ed)) {
        memcpy(cur, head, sizeof(head));
        flow += DFS(st, INF, ed);
    }
    return flow;
}

int T, n, m;
bool _vis[15][15];
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
struct node {
    int x;
    int y;
    int step;
}e;

int b_bfs(int sx, int sy) {
    memset(_vis, 0, sizeof(_vis));
    queue<node> que;
    e.x = sx, e.y = sy, e.step = 0;
    que.push(e);
    _vis[sx][sy] = 1;
    while(!que.empty()) {
        e = que.front();
        if(ma[e.x][e.y] == 'D') {
            return e.step;
        }
        que.pop();
        for(int i = 0; i < 4; ++i) {
            node ee;
            ee.x = e.x + dx[i];
            ee.y = e.y + dy[i];
            ee.step = e.step + 1;
            if(ee.x < 1 || ee.x > n || ee.y < 1 || ee.y > m) continue;
            if(ma[ee.x][ee.y] == 'X' || _vis[ee.x][ee.y]) continue;
            _vis[ee.x][ee.y] = 1;
            que.push(ee);
        }
    }
    return -1;
}

int main()
{
    scanf("%d\n", &T);
    while(T--) {
        init();
        scanf("%d %d", &n, &m);
        int x[50], y[50], p = 1, num = 0;
        for(int i = 1; i <= n; ++i) {
            getchar();
            for(int j = 1; j <= m; ++j) {
                scanf("%c", &ma[i][j]);
                if(ma[i][j] == '.') {
                    x[p] = i;
                    y[p++] = j;
                }
                else if(ma[i][j] == 'D') num++;
            }
        }
        int res[50], cnt = 0; bool flag = true;
        for(int i = 1; i < p; ++i) {
            res[i] = b_bfs(x[i], y[i]);
            cnt = max(cnt, res[i]);
            if(res[i] < 0) {
                flag = false;
                break;
            }
        }
        if(!flag) {
            puts("impossible");
            continue;
        }
        for(int i = 1; i < p; ++i) {
            addedge(0, i, 1);
            for(int j = res[i]; j <= cnt; ++j) {
                addedge(i, p + j, 1);
            }
        }
        int L = cnt, R = cnt * 4;
        while(R - L >= 1) {
            cnt = (L + R) >> 1;
            for(int i = 1; i < p; ++i) {//加边是关键
                addedge(0, i, 1);
                for(int j = res[i]; j <= cnt; ++j) {
                    addedge(i, p + j, 1);
                }
            }
            for(int i = 1; i <= cnt; ++i) {
                addedge(p + i, 500, num);
            }
            int ans = Maxflow(0, 500);
            /*
            printf("%d %d\n", ans, cnt);
            if(ans == p - 1) {
                printf("%d\n", cnt);
                break;
            }
            */
            if(ans <= p - 1) {
                L = cnt;
            }
            else R = cnt;
        }
        printf("%d\n", L);
    }
    return 0;
}