[HNOI2007]紧急疏散EVACUATE

嘟嘟嘟

看数据范围，第一反应觉得爆搜是不是能骗点分，但发现爆搜太难写了，于是就开始想想正解……

正解大概猜到了是网络流，但是怎么把时间这个条件加入到图的内容中，却困扰了我好半天，总是感觉把这种不同维度的条件整合到一块肯定得用什么很奇葩的方法，于是我就想不出来了……

看题解。

先二分时间（有道理啊，我怎么没想出来）。

然后我们可以转化一下，每一个人都已经到达了门前，不过到达的时刻不同，也就是说，对于这个人和这扇门他只能在大于等于他的到达时间的时候进去。

题中还说，一扇门一秒只能进一个人，为了把这个限制条件体现出来，我们把每一扇门拆点：对于当前二分的值mid，把每一扇门拆成mid + 1(包括0这个时刻)个点，每一个点向汇点连一条容量为1的边，然后对于一个人在哪个时候到达这个门的，就像第几时刻的点连一条容量为1的边。

还有一点，就是如果第 i 时刻人数大于1的话，那自然的剩下的人要等到 j (j > i)的时刻才能进门，为了体现这个，我们还要把每一扇门的每一个拆点 i，向 i +1连一条容量为INF的边。

建图到这里就讲完了，接下来说一下预处理。

首先我们要预处理每一个人到每一扇门的距离，而不是只到最近的门，因为虽然最近，但可能等待的时间非常长。我们可以从每一扇门开始对这个图来一次bfs，记录每一个点到这扇门的距离（我存到了一个vector中）。

然后二分重新建图的时候对于每一个点，从源点连一条容量为1的边；对于每一扇门，先按时间拆点，然后遍历自己的vector连边就行可以了。

还有一个值得注意的就是点的编号别重了，而且要确定好汇点的编号是多大：理论上最大值应该是20 * 20 + 76 * 20 * 20 = 30800, 76是最多有76扇门，但实际上我们只用开1e4就能过了。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define rg register
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 1e4 + 5;
const int max_map = 405;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), last = ' ';
    while(!isdigit(ch)) {last = ch; ch = getchar();}
    while(isdigit(ch)) {ans = ans * 10 + ch - '0'; ch = getchar();}
    if(last == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) x = -x, putchar('-');
    if(x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

int n, m, t, tot1 = 0, tot2 = 0;
char a[25][25];

int getnum(int x, int y)
{
    return (x - 1) * m + y;
}

#define pr pair<int, int>
#define mp make_pair
vector<pr> E[max_map];
struct Node
{
    int x, y, dis;
};
const int dx[5] = {-1, 0, 1, 0}, dy[5] = {0, 1, 0, -1};
bool vis[25][25];
void bfs1(int x, int y)
{
    Mem(vis, 0);
    int u = getnum(x, y);
    queue<Node> q; q.push((Node){x, y, 0});
    vis[x][y] = 1;
    while(!q.empty())
    {
        int x = q.front().x, y = q.front().y, Dis = q.front().dis;
        q.pop();
        for(int i = 0; i < 4; ++i)
        {
            int newx = x + dx[i], newy = y + dy[i];
            if(newx > 0 && newx <= n && newy > 0 && newy <= m && a[newx][newy] == '.' && !vis[newx][newy])
            {
                E[u].push_back(mp(getnum(newx, newy), Dis + 1));
                vis[newx][newy] = 1;
                q.push((Node){newx, newy, Dis + 1});
            }
        }
    }
    
}

void init()
{
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= m; ++j) 
        {
            if(a[i][j] == '.') tot1++;
            if(a[i][j] == 'D') tot2++, bfs1(i, j);
        }
}

struct Edge
{
    int from, to, cap, flow;
};
vector<Edge> edges;
vector<int> G[maxn];
void addEdge(int from, int to, int w)
{
    edges.push_back((Edge){from, to, w, 0});
    edges.push_back((Edge){to, from, 0, 0});
    int sz = edges.size();
    G[from].push_back(sz - 2);
    G[to].push_back(sz - 1);
}

void build_Gra(int x)
{
    edges.clear();
    for(int i = 0; i <= t; ++i) G[i].clear();
    int cnt = 0;
    for(int i = 1; i <= n; ++i)
        for(int j = 1; j <= m; ++j)
        {
            if(a[i][j] == '.') addEdge(0, getnum(i, j), 1);
            if(a[i][j] == 'D')
            {
                int u = getnum(i, j);
                int tp = n * m + cnt * x;
                for(int k = 1; k <= x; ++k) addEdge(tp + k, t, 1);
                for(int k = 1; k < x; ++k) addEdge(tp + k, tp + k + 1, INF);
                for(int k = 0; k < (int)E[u].size(); ++k)
                {
                    int nod = E[u][k].first, d = E[u][k].second;
                    if(d <= x) addEdge(nod, tp + d, 1);
                }
                cnt++;
            }
        }
}

int dis[maxn];
bool bfs()
{
    Mem(dis, 0); dis[0] = 1;
    queue<int> q; q.push(0);
    while(!q.empty())
    {
        int now = q.front(); q.pop();
        for(int i = 0; i < (int)G[now].size(); ++i)
        {
            Edge& e = edges[G[now][i]];
            if(!dis[e.to] && e.cap > e.flow)
            {
                dis[e.to] = dis[now] + 1;
                q.push(e.to);    
            }
        }
    }
    return dis[t];
}
int cur[maxn];
int dfs(int now, int res)
{
    if(now == t || res == 0) return res;
    int flow = 0, f;
    for(int& i = cur[now]; i < (int)G[now].size(); ++i)
    {
        Edge& e = edges[G[now][i]];
        if(dis[e.to] == dis[now] + 1 && (f = dfs(e.to, min(res, e.cap - e.flow))) > 0)
        {
            e.flow += f;
            edges[G[now][i] ^ 1].flow -= f;
            flow += f; res -= f;
            if(res == 0) break;
        }
    }
    return flow;
}

int maxflow()
{
    int flow = 0;
    while(bfs())
    {
        Mem(cur, 0);
        flow += dfs(0, INF);
    }
    return flow;
}

int main()
{
    n = read(); m = read();
    for(int i = 1; i <= n; ++i) scanf("%s", a[i] + 1);
    init();
    t =  n * m * (tot2 + 1) + 1;
    int L = 0, R = n * m + 1;
    while(L < R)
    {
        int mid = (L + R) >> 1;
        build_Gra(mid);
        if(maxflow() >= tot1) R = mid;
        else L = mid + 1;
    }
    if(L > n * m) printf("impossible
"); 
    else write(L), enter;
    return 0;
}