BZOJ1189: [HNOI2007]紧急疏散evacuate(二分答案，最大流)

Description

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

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

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

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

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

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

不可能。

Input

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

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

Output

只有一个整数K，表示让所有人安全撤离的最短时间，

如果不可能撤离，那么输出'impossible'（不包括引号）。

Sample Input

5 5
XXXXX
X...D
XX.XX
X..XX
XXDXX

Sample Output

3

解题思路：

考虑每个点到每个门的最短路一定所以先Bfs/Dijstra一遍得到每个点到每个门到最短距离。

考虑随着时间的推移，每个点能够到达的门也就越多，所以可以说是动态加边。

这时的正确方法是二分答案，建图网络流。

显然是源点连人，在时间允许的情况下人连门，容量为1。门连汇点，容量为T。

这样做理论上是很好的，但是有一个问题，那就是本题的特殊性，每个格子可以重复走人但是门只能一个一个出。

这就十分不和谐了，因为上面的做法并不能处理两个人同时到达的情况。

考虑一个问题，到底是什么性质没有被体现导致建图瑕疵。

这里可以认为门在T时刻关闭，那么本质上每个人都有一个剩余时间，假如说一起到然后一个一个出，

这里的问题就是假如说一起到的人比较多，假如说大于T那么一定不能全部出去。

所以需要有一个条件来限制每个人到达时还剩多少时间，换句话说，需要表现他究竟是什么时间到达的。

这样，将每个门拆成T个点，代表该时刻到达的门（相当于给门分层）。

每个点向到达时间的门连边，每层门向下一层连流量为$inf$的边。

跑最大流验证就好了。

代码：

#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
const int oo=0x3f3f3f3f;
struct int_2{int TIME;int NO;};
struct pnt{
    int hd;
    int lyr;
    int now;
}p[1000000];
struct ent{
    int twd;
    int vls;
    int lst;
    int his;
}e[5000000];
struct OVO{
    int_2 pro;
    int i;
    int j;
};
int cnt;
int n,m;
int s,t;
int pnum;
char tmp[100];
int no[21][21];
int mp[21][21];
bool vis[21][21];
bool hvv[21][21];
std::queue<int>Q;
std::queue<OVO>P;
std::vector<int>T[1000];
std::vector<int_2>dr[21][21];
void ade(int f,int t,int v)
{
    cnt++;
    e[cnt].twd=t;
    e[cnt].vls=v;
    e[cnt].his=v;
    e[cnt].lst=p[f].hd;
    p[f].hd=cnt;
    return ;
}
bool bfs(void)
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(mp[i][j]==2)
            {
                while(!P.empty())
                    P.pop();
                P.push((OVO){(int_2){0,no[i][j]},i,j});
                while(!P.empty())
                {
                    OVO x=P.front();
                    P.pop();
                    int ii=x.i;
                    int jj=x.j;
                    if(vis[ii][jj])
                        continue;
                    vis[ii][jj]=true;
                    if(mp[ii][jj]==1)
                        dr[ii][jj].push_back(x.pro);
                    x.pro.TIME++;
                    OVO y;
                    y=x;
                    y.i++;
                    if(y.i<=n)
                    {
                        if(mp[y.i][y.j]==1)
                        {
                            P.push(y);
                        }
                    }
                    y=x;
                    y.i--;
                    if(y.i>0)
                    {
                        if(mp[y.i][y.j]==1)
                        {
                            P.push(y);
                        }
                    }
                    y=x;
                    y.j++;
                    if(y.j<=m)
                    {
                        if(mp[y.i][y.j]==1)
                        {
                            P.push(y);
                        }
                    }
                    y=x;
                    y.j--;
                    if(y.j>0)
                    {
                        if(mp[y.i][y.j]==1)
                        {
                            P.push(y);
                        }
                    }
                }
                for(int ii=1;ii<=n;ii++)
                {
                    for(int jj=1;jj<=m;jj++)
                    {
                        if(vis[ii][jj])
                            hvv[ii][jj]=true;
                        vis[ii][jj]=false;
                    }
                }
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(!hvv[i][j]&&mp[i][j]==1)
                return true;
        }
    }
    return false;
}
bool Bfs(void)
{
    while(!Q.empty())Q.pop();
    for(int i=1;i<=t;i++)
        p[i].lyr=0;
    p[s].lyr=1;
    Q.push(s);
    while(!Q.empty())
    {
        int x=Q.front();
        Q.pop();
        for(int i=p[x].hd;i;i=e[i].lst)
        {
            int to=e[i].twd;
            if(p[to].lyr==0&&e[i].vls>0)
            {
                p[to].lyr=p[x].lyr+1;
                if(to==t)
                    return true;
                Q.push(to);
            }
        }
    }
    return false;
}
int Dfs(int x,int fll)
{
    if(x==t)
        return fll;
    for(int& i=p[x].now;i;i=e[i].lst)
    {
        int to=e[i].twd;
        if(p[to].lyr==p[x].lyr+1&&e[i].vls>0)
        {
            int ans=Dfs(to,std::min(fll,e[i].vls));
            if(ans>0)
            {
                e[i].vls-=ans;
                e[((i-1)^1)+1].vls+=ans;
                return ans;
            }
        }
    }
    return 0;
}
int Dinic(void)
{
    int ans=0;
    while(Bfs())
    {
        for(int i=1;i<=t;i++)
            p[i].now=p[i].hd;
        int dlt;
        while(dlt=Dfs(s,oo))
            ans+=dlt;
    }
    return ans;
}
bool Check(int x)
{
    for(int i=1;i<=t;i++)
        p[i].hd=0;
    cnt=0;
    int lcnt=n*m;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            if(mp[i][j]==2)
            {
                T[no[i][j]].clear();
                for(int k=0;k<=x;k++)
                    T[no[i][j]].push_back(++lcnt);
            }
    s=lcnt+1;
    t=s+1;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(mp[i][j]==1)
            {
                ade(s,no[i][j],1);
                ade(no[i][j],s,0);
                for(int k=0;k<dr[i][j].size();k++)
                {
                    if(dr[i][j][k].TIME<=x)
                    {
                        ade(no[i][j],T[dr[i][j][k].NO][dr[i][j][k].TIME],1);
                        ade(T[dr[i][j][k].NO][dr[i][j][k].TIME],no[i][j],0);
                    }
                }
            }else if(mp[i][j]==2)
            {
                for(int k=0;k<=x;k++)
                {
                    ade(T[no[i][j]][k],t,1);
                    ade(t,T[no[i][j]][k],0);
                    if(k!=x)
                    {
                        ade(T[no[i][j]][k],T[no[i][j]][k+1],oo);
                        ade(T[no[i][j]][k+1],T[no[i][j]][k],0);
                    }
                }
            }
        }
    }
    return pnum==Dinic();
}
int main()
{
//    freopen("a.in","r",stdin);
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%s",tmp+1);
        for(int j=1;j<=m;j++)
        {
            no[i][j]=++cnt;
            if(tmp[j]=='X')
                mp[i][j]=0;
            if(tmp[j]=='.')
                mp[i][j]=1,
                pnum++;
            if(tmp[j]=='D')
                mp[i][j]=2;
        }
    }
    cnt=0;
    if(bfs())
    {
        puts("impossible");
        return 0;
    }
    int l=0,r=1000;
    int ans;
    while(l<=r)
    {
        int mid=(l+r)>>1;
        if(Check(mid))
        {
            ans=mid;
            r=mid-1;
        }else
            l=mid+1;
    }
    printf("%d\n",ans);
    return 0;
}