POJ 3057 网络流 Evacuation

题意：

有一个n×m的房间，四周每个格子要么是墙要么是门。中间部分是墙或者人。

现在所有人要从房间逃出去，每个人的速度为1，也就是每个单位时间只能向上下左右四个方向走一格。

多个人可以站在同一个格子上，但是每个时刻每个门只能通过一格人，求所有人从房间中逃出去所需要的最少时间。

分析：

把每个人看成一个点，然后把每个时刻和门组成的二元组看成一个点。

如果两点之间连一条边表示这个人在这个时刻从这个门逃出去。

所以我们可以从小到大将时间逐渐加1，直到找到最大匹配为止。

在增加点的时候，可以在之前最大流基础上增广，这样更快。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#define MP make_pair
using namespace std;

typedef pair<int, int> PII;

const int INF = 0x3f3f3f3f;
const int maxh = 15;
const int maxnode = 20000;

char maze[maxh][maxh];
int id[maxh][maxh];

int row, col;

vector<PII> people, doors;

int dx[] = { 1, 0, -1, 0 };
int dy[] = { 0, 1, 0, -1 };

int dist[50][130];  //the distance from every door to people
int steps[maxh][maxh];

bool inline in(int x, int y) { return x >= 0 && x < row && y >= 0 && y < col; }

bool vis[maxh][maxh];

void bfs(PII s)
{
    int st = id[s.first][s.second];
    steps[s.first][s.second] = 0;
    queue<PII> Q;
    Q.push(s);
    memset(vis, false, sizeof(vis));
    vis[s.first][s.second] = true;

    while(!Q.empty())
    {
        PII t = Q.front(); Q.pop();
        for(int i = 0; i < 4; i++)
        {
            int x = t.first + dx[i];
            int y = t.second + dy[i];
            if(in(x, y) && !vis[x][y] && maze[x][y] == '.')
            {
                vis[x][y] = true;
                dist[st][id[x][y]] = steps[x][y] = steps[t.first][t.second] + 1;
                Q.push(MP(x, y));
            }
        }
    }
}

struct Edge
{
    int from, to, cap, flow;
    Edge(int u, int v, int c, int f):from(u), to(v), cap(c), flow(f) {}
};

int nodes;
vector<int> G[maxnode];
vector<Edge> edges;

void init()
{
    edges.clear();
    for(int i = 0; i < nodes; i++) G[i].clear();
}

void AddEdge(int u, int v, int cap)
{
    edges.push_back(Edge(u, v, cap, 0));
    edges.push_back(Edge(v, u, 0, 0));
    int m = edges.size();
    G[u].push_back(m - 2);
    G[v].push_back(m - 1);
}

int s, t;
bool visit[maxnode];
int d[maxnode], cur[maxnode];

bool BFS()
{
    memset(visit, false, sizeof(visit));
    queue<int> Q;
    Q.push(s);
    d[s] = 0;
    visit[s] = true;

    while(!Q.empty())
    {
        int u = Q.front(); Q.pop();
        for(int i = 0; i < G[u].size(); i++)
        {
            Edge& e = edges[G[u][i]];
            int v = e.to;
            if(!visit[v] && e.cap > e.flow)
            {
                visit[v] = true;
                Q.push(v);
                d[v] = d[u] + 1;
            }
        }
    }

    return visit[t];
}

int DFS(int u, int a)
{
    if(u == t || a == 0) return a;
    int flow = 0, f;
    for(int& i = cur[u]; i < G[u].size(); i++)
    {
        Edge& e = edges[G[u][i]];
        int v = e.to;
        if(d[v] == d[u] + 1 && (f = DFS(v, min(a, e.cap - e.flow))) > 0)
        {
            e.flow += f;
            edges[G[u][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(a == 0) break;
        }
    }
    return flow;
}

int Maxflow()
{
    int flow = 0;
    while(BFS())
    {
        memset(cur, 0, sizeof(cur));
        flow += DFS(s, INF);
    }
    return flow;
}

void Readuce()
{
    for(int i = 0; i < edges.size(); i++)
        edges[i].cap -= edges[i].flow, edges[i].flow = 0;
}

int main()
{
    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d%d", &row, &col);
        for(int i = 0; i < row; i++) scanf("%s", maze[i]);

        memset(id, 0, sizeof(id));
        people.clear(); doors.clear();
        int psz = 0, dsz = 0;
        for(int i = 0; i < row; i++)
            for(int j = 0; j < col; j++)
            {
                if(maze[i][j] == 'D') { doors.push_back(MP(i, j)); id[i][j] = dsz++; }
                else if(maze[i][j] == '.') { people.push_back(MP(i, j)); id[i][j] = psz++; }
            }

        memset(dist, 0x3f, sizeof(dist));
        for(int i = 0; i < dsz; i++) bfs(doors[i]);
        bool unreachable = false;
        for(int i = 0; i < psz; i++)
        {
            bool reach = false;
            for(int j = 0; j < dsz; j++)
                if(dist[j][i] < INF) { reach = true; break; }
            if(reach == false) { unreachable = true; break; }
        }

        if(unreachable) { puts("impossible"); continue; }

        int tot_time = 0;
        s = 0, t = 1;
        nodes = 2 + psz;
        init();
        for(int i = 0; i < psz; i++) AddEdge(s, i + 2, 1);

        int matches = 0;
        for(;;)
        {
            tot_time++;
            for(int i = 0; i < dsz; i++)
            {
                G[nodes].clear();
                AddEdge(nodes, t, 1);
                for(int j = 0; j < psz; j++)
                    if(dist[i][j] <= tot_time) AddEdge(j + 2, nodes, 1);
                nodes++;
            }
            matches += Maxflow();
            if(matches == psz) break;
            Readuce();
        }
        printf("%d
", tot_time);
    }

    return 0;
}