题解 P3191 [HNOI2007]紧急疏散EVACUATE

题解

本篇题解做法为BFS+二分+最大流

二分需要撤离的时间，也就是答案（这算是一个比较套路的了）

重点在于建模（设时间为 (tim)）：

1. 我们将每个门拆点，拆成 (tim) 个，每个点向汇点连边，边权为 (1)，代表每个门在 (tim) 内能送走的人

2. 将源点和每个空地连边，边权为 (1) 代表这个空地有一个人

3. 先进行一次BFS，算出每个人到不同门的时间

4. 将每个人和它在 (tim) 时间内能到的门连边，边权为 (1)，注意，连的是，那个门拆出的 (tim_i) 门。

5. 如果有多个人在同一时间到达同一个门，怎么解决？我们再将每个门的 (tm) 向 (tm+1) 连一条边权为 (INF) 的边 ((tmin [1,tim) ;;;and;;tmin Z))

剩下的就是一些小优化了，记得输入要开 scanf("%s")

Code

#include<bits/stdc++.h>
#define ri register signed
#define p(i) ++i
using namespace std;
namespace IO{
    char buf[1<<21],*p1=buf,*p2=buf;
    #define gc() p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++
    inline int read() {
        ri x=0,f=1;char ch=getchar();
        while(ch<'0'||ch>'9') {if (ch=='-') f=-1;ch=getchar();}
        while(ch>='0'&&ch<='9') {x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
        return x*f;
    }
}
using IO::read;
namespace nanfeng{
    #define node(x,y,id) (node){x,y,id}
    #define jud(x,y) (x>=1&&x<=n&&y>=1&&y<=m&&(k=idp[x][y])>0)
    #define cmax(x,y) ((x)>(y)?(x):(y))
    #define cmin(x,y) ((x)>(y)?(y):(x))
    #define FI FILE *IN
    #define FO FILE *OUT
    #undef bool
    static const int N=25;
    int idp[N][N],dis[N*N][N*N],dx[5]={0,1,0,-1,0},dy[5]={0,0,-1,0,1},tot,out,n,m;
    char s[N];
    struct node{int x,y,id;};
    struct Que{
        node que[N*N];
        int hd,tl;
        inline void init() {hd=1,tl=0;}
        inline void push(node q) {que[p(tl)]=q;}
        inline node top() {return que[hd++];}
        inline bool empty() {return hd>tl;}
    }que;
    inline void bfs(int id,int x,int y) {
        memset(dis[id],127,sizeof(dis[id]));
        que.init();
        que.push(node(x,y,0));
        dis[id][0]=0;//我们将dis的第二维换成点（i，j）的编号，三位数组寻址太慢
        while(!que.empty()) {
            node tmp=que.top();
            for (ri d(1);d<=4;p(d)) {
                int tx=tmp.x+dx[d],ty=tmp.y+dy[d],k;
                if (!jud(tx,ty)) continue;
                if (dis[id][k]>dis[id][tmp.id]+1) dis[id][k]=dis[id][tmp.id]+1,que.push(node(tx,ty,k)); 
            }
        }
    }
    namespace NetworkFlow{//封装
        static const int INF=1e9+7;
        static const int NUM=N*N*N;
        int first[NUM],dep[NUM],cur[NUM],que[NUM],t=2,s,et;
        struct edge{int v,nxt,w;}e[NUM*N*N>>1];
        inline void add(int u,int v,int w) {
            e[t].v=v,e[t].w=w;
            e[t].nxt=first[u];
            first[u]=t++;
        }
        inline void init() {memset(first,0,sizeof(first));t=2;}
        inline void build(ri tim) {
            int tt=out*tim;
            et=tt+tot+1;
            for (ri d(1);d<=out;p(d)) {
                for (ri i(1);i<=tim;p(i)) {
                    ri bs=tim*(d-1);
                    add(bs+i,et,1),add(et,bs+i,0);
                    if (i<tim) add(bs+i,bs+i+1,INF),add(bs+i+1,bs+i,0);
                }
            }
            for (ri i(1);i<=tot;p(i)) add(s,tt+i,1),add(tt+i,s,0);
            for (ri d(1);d<=out;p(d)) {
                for (ri i(1),bs;i<=tot;p(i)) 
                    if (dis[d][i]<=tim) add(tt+i,bs=(d-1)*tim+dis[d][i],1),add(bs,tt+i,0);
            }
        }
        inline bool bfs(int s,int t) {
            memset(dep,0,sizeof(dep));
            int hd=1,tl=0;
            dep[que[p(tl)]=s]=1;
            cur[s]=first[s];
            while(hd<=tl) {
                s=que[hd++];
                for (ri i(first[s]),v;i;i=e[i].nxt) {
                    if (e[i].w&&!dep[v=e[i].v]) {
                        dep[que[p(tl)]=v]=dep[s]+1;
                        cur[v]=first[v];
                        if (v==t) return 1;
                    }
                }
            }
            return 0;
        }
        int dfs(int x,int flow) {
            if (x==et||!flow) return flow;
            int rst=flow;
            for (ri i(cur[x]),v;i&&rst;i=e[i].nxt) {
                if (e[i].w&&dep[v=e[i].v]==dep[x]+1) {
                    ri k=dfs(v,cmin(e[i].w,rst));
                    if (!k) dep[v]=0;
                    e[i].w-=k,e[i^1].w+=k,rst-=k;
                }
                cur[x]=i;//弧优化
            }
            return flow-rst;
        }
        inline int dinic() {
            int res=0;
            while(bfs(s,et)) res+=dfs(s,INF);
            return res;
        }
    }
    inline bool check(int tim) {
        NetworkFlow::init();
        NetworkFlow::build(tim);
        return NetworkFlow::dinic()==tot;
    }
    inline int main() {
        // FI=freopen("nanfeng.in","r",stdin);
        // FO=freopen("nanfeng.out","w",stdout);
        n=read(),m=read();
        for (ri i(1);i<=n;p(i)) {
            scanf("%s",s+1);//记得%s
            for (ri j(1);j<=m;p(j)) 
                if (s[j]=='.') idp[i][j]=p(tot);
                else if (s[j]=='X') idp[i][j]=-1;
        }
        for (ri i(1);i<=n;p(i)) {
            for (ri j(1);j<=m;p(j)) 
                if (!idp[i][j]) bfs(p(out),i,j);
        }
        ri l=0,r=tot+1,res=-1;
        while(l<=r) {
            int mid((l+r)>>1);
            if (check(mid)) r=mid-1,res=mid;
            else l=mid+1;
        }
        res==-1?puts("impossible"):printf("%d
",res);
        return 0;
    }
}
int main() {return nanfeng::main();}