BZOJ 1189: [HNOI2007]紧急疏散evacuate 二分+最大流

原文链接： http://www.cnblogs.com/G-hsm/p/11321920.html

title

BZOJ 1189
LUOGU 3191
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

HINT

2015.1.12新加数据一组，鸣谢1756500824（这位亲真是个神仙）

analysis

思路比较好想，然而不会写，参照了 hzwer 的建图方法：

1. 对于每个门进行一次bfs，得出每个点到每个门的时间；
2. 然后二分时间，每次建图dinic；
3. S到空地连一条容量1的边，每个空地到可到达的门连一条容量1的边，每个门到T连一条容量为时间的边。

然后这种方法无法处理两个人同时在最后时刻赶到一个门的情况，就像上面那位神仙出的这组数据：

4 5
XXDXX
XX.XX
X...X
XXDXX
ans=3

所以被卡了。

当时选择无视，现在决定来搞搞了，自己竟然还是没想出来，看到了 租酥雨，额，队爷 \(Orz\)。
他的解决方法就是从每扇门对应时间 \(t\) 的点向 \(t+1\) 的点连一条 \(inf\) 的边，而且他的 \(bfs\) 好像处理的感觉更好啊，所以改代码吧。

code

#include
using namespace std;
const int dx[]={0,0,1,-1},dy[]={1,-1,0,0};
const int maxn=1e5+10,maxm=1e6+10,inf=0x3f3f3f3f;

char buf[1<<15],*fs,*ft;
inline char getc() { return (ft==fs&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),ft==fs))?0:*fs++; }
templateinline void read(T &x)
{
    x=0;
    T f=1, ch=getchar();
    while (!isdigit(ch) && ch^'-') ch=getchar();
    if (ch=='-') f=-1, ch=getchar();
    while (isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48), ch=getchar();
    x*=f;
}

templateinline void write(T x)
{
    if (!x) { putchar('0'); return ; }
    if (x<0) putchar('-'), x=-x;
    T num=0, ch[20];
    while (x) ch[++num]=x%10+48, x/=10;
    while (num) putchar(ch[num--]);
}

int ver[maxm],edge[maxm],Next[maxm],head[maxn],len=1;
inline void add(int x,int y,int z)
{
    ver[++len]=y,edge[len]=z,Next[len]=head[x],head[x]=len;
    ver[++len]=x,edge[len]=0,Next[len]=head[y],head[y]=len;
}

int s,t;
int dist[maxn];
inline bool bfs()
{
    queueq;
    memset(dist,0,sizeof(dist));
    q.push(s);dist[s]=1;
    while (!q.empty())
    {
        int x=q.front();
        q.pop();
        for (int i=head[x]; i; i=Next[i])
        {
            int y=ver[i];
            if (edge[i] && !dist[y])
            {
                dist[y]=dist[x]+1;
                if (y==t) return 1;
                q.push(y);
            }
        }
    }
    return 0;
}

inline int get(int x,int low)
{
    if (x==t) return low;
    int tmp=low;
    for (int i=head[x]; i; i=Next[i])
    {
        int y=ver[i];
        if (edge[i] && dist[y]==dist[x]+1)
        {
            int a=get(y,min(tmp,edge[i]));
            if (!a) dist[y]=0;
            edge[i]-=a;
            edge[i^1]+=a;
            if (!(tmp-=a)) break;
        }
    }
    return low-tmp;
}

inline int Dinic()
{
    int ans=0;
    while (bfs()) ans+=get(s,inf);
    return ans;
}

char ch[21][21];
struct Orz{int x,y;};
queueQ;
int P[21][21],d[401][21][21],n,m,door,people;
inline void BFS(int k,int a,int b)//第k扇门，它的位置是(a,b)
{
    for (int i=1; i<=n; ++i)
        for (int j=1; j<=m; ++j) d[k][i][j]=inf;
    d[k][a][b]=0,Q.push((Orz){a,b});
    while (!Q.empty())
    {
        int x=Q.front().x,y=Q.front().y;
        Q.pop();
        for (int l=0; l<4; ++l)
        {
            int i=x+dx[l],j=y+dy[l];
            if (i<1 || j<1 || i>n || j>m || ch[i][j]^'.') continue;
            if (d[k][i][j]>d[k][x][y]+1) d[k][i][j]=d[k][x][y]+1,Q.push((Orz){i,j});
        }
    }
}

inline void build(int mid)
{
    #define hs(i,j) (((i)-1)*mid+(j))//宏，要小心
    memset(head,0,sizeof(head));
    len=1; s=door*mid+people+1, t=s+1;
    for (int k=1; k<=door; ++k)
        for (int i=1; i<=mid; ++i)
        {
            add(hs(k,i),t,1);
            if (i>1;
        build(mid);
        if (Dinic()==people) ans=mid,r=mid-1;
        else l=mid+1;
    }
    if (ans==-1) puts("impossible");
    else write(ans),puts("");
    return 0;
}

转载于:https://www.cnblogs.com/G-hsm/p/11321920.html