POJ 3057 Evacuation （最大流加边）

题意：

         X * Y的区域，'.'为空格，'D'为门，'#'为墙，

         每个空格处有一人，每个人每秒只能移动一步，

         每个门每秒只允许一个人通过，

          求所有人逃脱的最短时间，如果有人无法逃脱，输出"impossible"

分析：

           网上的题解大部分都是二分+最大匹配or最大流。

           挑战上有二分图匹配不用的二分的。（效率高些）

           我的做法是最大流，类似上面所说挑战的做法，不断的加边继续增广。   （二分答案的做法，每次都要重新全部再跑一次，重复了很多操作）

          建图：

               源点--->人--->各个时间的门---->汇点      边权都为1

           时间从1开始递增，最大不超过人数。加一个时间单位就把每个人能在这个时间内，到达这个时间点的门，连一条边，然后继续增广。（这个时间点的门记得连汇点）

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<vector>
#include<cctype>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<iomanip>
#include<sstream>
#include<limits>
#define ll long long
#define inf 0x3f3f3f3f
using namespace std;
const int maxm = 1e6+10;
const int MOD = 1e9+7;
#define INF 0x7fffffff
const int maxn = 1e5+10;

struct Edge{
    int to , cap,rev;  // rev反向边
};
vector<Edge>G[maxn];
int level[maxn],iter[maxn];  // 顶点到源点的标号   当前弧
void add_edge(int from,int to,int cap) //cap容量
{
    G[from].push_back((Edge){to,cap,G[to].size()});
    G[to].push_back((Edge){from,0,G[from].size()-1 });
}
void bfs(int s) // 分层
{
    memset(level,-1,sizeof(level));
    queue<int>que;
    level[s] = 0;
    que.push(s);
    while(!que.empty())
    {
        int v = que.front();que.pop();
        for(int i = 0; i < G[v].size(); i++)
        {
            Edge &e = G[v][i];
            if (e.cap>0 && level[e.to] < 0)
            {
                level[e.to] = level[v]+1;
                que.push(e.to);
            }
        }
    }
}
int dfs(int v, int t, int f) //寻增广路
{
    if (v==t) return f;
    for(int &i = iter[v]; i < G[v].size(); i++)
    {
        Edge &e = G[v][i];
        if (e.cap > 0 && level[v] < level[e.to])
        {
            int d = dfs(e.to , t, min(f,e.cap));
            if (d > 0)
            {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s, int t) // s到t最大流
{
    int flow = 0;
    for(;;)
    {
        bfs(s);
        if (level[t] < 0) return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f = dfs(s,t,INF)) > 0) { flow += f;}
    }
}
struct Point{
   int x,y;
};
vector<Point> door;
char mp[1010][1010];
int d[200][100][100],id[1010][1010];
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
int n,m;
void  work()
{
    for(int i = 0; i < door.size(); i++)
    {
        int x = door[i].x, y = door[i].y;
        queue<Point> Q;
        d[i][x][y] = 0;         //x,y点的这个人到达第i号门的最短时间。
        Q.push({x,y});
        while(!Q.empty())
        {
            Point p = Q.front(); Q.pop();
            x = p.x; y = p.y;
            for(int g = 0; g < 4; g++)
             {
                 int nx = x + dx[g];
                 int ny = y + dy[g];
                 if (nx >=0 && nx < n && ny >= 0 && ny < m && mp[nx][ny] == '.')
                    if (d[i][nx][ny] > d[i][x][y]+1)
                    {
                         d[i][nx][ny] = d[i][x][y]+1;
                         Q.push({nx,ny});
                    }
             }
        }
    }
}
int main(){
#ifdef LOCAL
	freopen("C:\\Users\\lanjiaming\\Desktop\\acm\\in.txt","r",stdin);
	//freopen("output.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0);
    int T;
    cin>>T;
    while(T--)
    {
        door.clear();
        cin>>n>>m;
        for(int i= 0; i <= 10000; i++) G[i].clear();
        int s = 0, t = 10000,cnt = 1,TT = 0;
        for(int i = 0; i < n; i++)
         {
             cin>>mp[i];
             for(int j = 0; j < m; j++)
             {
                 if (mp[i][j] == 'D') door.push_back({i,j});
                 if (mp[i][j] == '.')
                 {
                     TT++;   //人数
                     add_edge(s,cnt,1);
                     id[i][j] = cnt;
                     cnt++;
                 }
             }
         }
         memset(d,0x3f,sizeof(d));
         work(); //计算每个人到各个门的最短时间

         int ans = 0,tme = 0;
         for(int i = 1; i <= TT; i++)
         {
             for(int j = 0; j < door.size(); j++)   //加边
             {
                 add_edge(cnt,t,1);
                 for(int g = 0; g < n; g++)
                    for(int h = 0; h < m; h++)
                       if (d[j][g][h] <= i && mp[g][h] == '.') add_edge(id[g][h],cnt,1);
                 cnt++;
             }
             ans += max_flow(s,t);
           // cout<<"    "<<ans<<endl;
             if (ans >= TT)
             {
                 tme = i;
                 break;
             }
         }
         if (ans < TT) cout<<"impossible\n";
         else cout<<tme<<endl;
    }
    return 0;
}