bzoj 1189: [HNOI2007]紧急疏散evacuate 分层图最大流_拆点_二分

Description

发生了火警，所有人员需要紧急疏散！假设每个房间是一个N M的矩形区域。每个格子如果是'.'，那么表示这是一

块空地；如果是'X'，那么表示这是一面墙，如果是'D'，那么表示这是一扇门，人们可以从这儿撤出房间。已知门

一定在房间的边界上，并且边界上不会有空地。最初，每块空地上都有一个人，在疏散的时候，每一秒钟每个人都

可以向上下左右四个方向移动一格，当然他也可以站着不动。疏散开始后，每块空地上就没有人数限制了（也就是

说每块空地可以同时站无数个人）。但是，由于门很窄，每一秒钟只能有一个人移动到门的位置，一旦移动到门的

位置，就表示他已经安全撤离了。现在的问题是：如果希望所有的人安全撤离，最短需要多少时间？或者告知根本

不可能。

Input

第一行是由空格隔开的一对正整数N与M，3<=N <=20，3<=M<=20，

以下N行M列描述一个N M的矩阵。其中的元素可为字符'.'、'X'和'D'，且字符间无空格。

题解：

一眼分层图最短路，按时间将每个点拆开.

然而，空间时爆炸的，节点层数过多.

不过，我们有一个非常好的性质：由于任意时刻每个空格上不限人数，人们可以直接走最短路径走向每扇门.

这样，就不必对每一个空地拆点，只需将门按照时间拆开并连边即可.

处理最短路径我们选择 Floyd.

Code:

#include<bits/stdc++.h>
#define setIO(s) freopen(s".in","r",stdin)
#define maxn 100000
#define inf 100000
using namespace std;
namespace Dinic{
    struct Edge{
        int from,to,cap;
        Edge(int a=0,int b=0,int c=0):from(a),to(b),cap(c){}
    };
    queue<int>Q;
    vector<Edge>edges;
    vector<int>G[maxn];
    void add(int u,int v,int c){
        edges.push_back(Edge(u,v,c));
        edges.push_back(Edge(v,u,0));
        int m=edges.size();
        G[u].push_back(m-2);
        G[v].push_back(m-1);
    }
    int S,T,vis[maxn],d[maxn],current[maxn];
    int BFS(){
        memset(vis,0,sizeof(vis));
        vis[S]=1,d[S]=0; Q.push(S);
        while(!Q.empty()){
            int u=Q.front();Q.pop();
            for(int sz=G[u].size(),i=0;i<sz;++i){
                Edge r = edges[G[u][i]];
                if(!vis[r.to] && r.cap>0) {
                    vis[r.to]=1,d[r.to]=d[u]+1;
                    Q.push(r.to);
                }
            }
        }
        return vis[T];
    }
    int dfs(int x,int cur){
        if(x==T) return cur;
        int flow=0,f;
        for(int sz=G[x].size(),i=current[x];i<sz;++i){
            current[x]=i;
            Edge r = edges[G[x][i]];
            if(d[r.to]==d[x]+1&&r.cap>0) {
                if(f=dfs(r.to,min(cur,r.cap)))  {
                    flow+=f,cur-=f;
                    edges[G[x][i]].cap-=f,edges[G[x][i]^1].cap+=f;
                }
            }
            if(cur==0) break;
        }
        return flow;
    }
    int maxflow(){
        int flow=0;
        while(BFS()){
            memset(current,0,sizeof(current));
            flow+=dfs(S,inf);
        }
        return flow;
    }
    void re(){
        S=T=0;
        for(int i=0;i<maxn;++i) G[i].clear();
        edges.clear();
    }
};
char str[500];
int gr[500][500],d[500][500],ck[500][500];
#define idx(i,j) ((i-1)*m+j)
#define nex (id+10)
vector<int>gate,G[maxn];
int mapp[500][300],n,m,sum;
bool check(int t){
    int id=0;
    Dinic::re();
    Dinic::S=0,Dinic::T=5000;
    for(int sz=gate.size(),i=0;i<sz;++i) {
        mapp[gate[i]][0]=++id; Dinic::add(id,5000,1);
        for(int j=1;j<=t;++j) { mapp[gate[i]][j]=++id; Dinic::add(id-1,id,inf),Dinic::add(id,5000,1); }
    }
    int tot=n*m;
    for(int i=1;i<=tot;++i)  {
        for(int sz=G[i].size(),j=0;j<sz;++j) if(d[i][G[i][j]]<=t) Dinic::add(i+nex,mapp[G[i][j]][d[i][G[i][j]]],1);
        if(G[i].size()) Dinic::add(0,i+nex,1);
    }
    return (Dinic::maxflow()==sum);
}
int main(){
    //setIO("input");
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i){
        scanf("%s",str+1);
        for(int j=1;j<=m;++j) {
            if(str[j]=='.') gr[i][j]=0,++sum;
            if(str[j]=='X') gr[i][j]=1;
            if(str[j]=='D') { gr[i][j]=2; gate.push_back(idx(i,j)); }
        }
    }
    for(int i=1;i<=n*m;++i)
        for(int j=1;j<=n*m;++j) d[i][j]=inf;
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j) {
            if(i-1>=1&&gr[i-1][j]!=1) d[idx(i,j)][idx(i-1,j)]=ck[idx(i,j)][idx(i-1,j)]=1;
            if(i+1<=n&&gr[i+1][j]!=1) d[idx(i,j)][idx(i+1,j)]=ck[idx(i,j)][idx(i+1,j)]=1;
            if(j+1<=m&&gr[i][j+1]!=1) d[idx(i,j)][idx(i,j+1)]=ck[idx(i,j)][idx(i,j+1)]=1;
            if(j-1>=1&&gr[i][j-1]!=1) d[idx(i,j)][idx(i,j-1)]=ck[idx(i,j)][idx(i,j-1)]=1;
        }
    int tot=n*m;
    for(int i=1;i<=tot;++i) ck[i][i]=1,d[i][i]=0;
    for(int k=1;k<=tot;++k)
        for(int i=1;i<=tot;++i)
            for(int j=1;j<=tot;++j) if(ck[i][k]&&ck[k][j]) ck[i][j]=1;
    for(int k=1;k<=tot;++k)
        for(int i=1;i<=tot;++i)
            for(int j=1;j<=tot;++j) if(ck[i][j]) d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
    for(int i=1;i<=n;++i)
        for(int j=1;j<=m;++j)
            if(gr[i][j]==0){
                bool flag=0;
                for(int sz=gate.size(),t=0;t<sz;++t){
                    if(ck[idx(i,j)][gate[t]]) G[idx(i,j)].push_back(gate[t]);
                    flag=1;
                }
                if(!flag) { printf("impossible"); return 0; }
            }
    int l=1,r=400,ans,mid;
    while(l<=r){
        mid=(l+r)>>1;
        if(check(mid)) ans=mid,r=mid-1;
        else l=mid+1;
    }
    printf("%d",ans);
    return 0;
}