BZOJ1189: [HNOI2007]紧急疏散evacuate(二分+最大流拆点法)

最新推荐文章于 2019-05-18 21:33:00 发布
最新推荐文章于 2019-05-18 21:33:00 发布
阅读量654 收藏
点赞数 2
文章标签： network flow
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzi2018/article/details/88583884
版权

题意：传送门

题解：直接二分答案 mid，也就是所有人安全撤离所需时间， 通过最大流来判断逃生时间为 mid 时，所有人能否安全撤离，能则

缩小边界：

  1. 将源点 S 向每个空地连一条容量为 1 的边，表示每个空地初始时有一个人；

  2. 因为每一秒钟只能有一个人移动到门的位置，我们要将每个门拆成 mid 个点，分别表示时刻为第 1 ~ mid 秒的门，并向汇点 T 连一条容量为 1 的边；

  3. 为了简化问题，在二分答案前我们先 BFS 求出每块空地到每个门所需时间，然后将每块空地与对应所需时间的门连边，容量为1；

  4. 那么如果有一些人（人数大于等于1）进入任意一个时刻的门，那么这个时刻的这扇门对应的点必定有 1 的流量流入汇点，但可能会有多个人到达同一个门所需的时间相同，所以我们要让剩下的人等到下一秒再让其中一个人移动到门的位置，所以对于时刻为第 1 ~ mid - 1 秒的门，我们都要向时刻为下一秒的门连一条容量为无穷大的边（因为同一时刻到达门的人可能有任意多，且 mid >= 正确答案时，所有人所代表的流量都将流入汇点 T，所以这里就不多考虑人数了）；

  5. 判断如此建图的最大流是否等于总人数（总的空地数），如果一直无法相等则说明所有人无法全部安全撤出，输出“impossible”。

  6. 最后附上一组样例：

    4 5
XXDXX
XX.XX
X...X
XXDXX

     

附上代码(vector版)：

#include<bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxn=20+5;
const int maxt=5e4+5;
const int dx[]={-1,1,0,0},dy[]={0,0,-1,1};
int n,m,E,R,GG[maxn][maxn],dis[100][maxn][maxn],src,des;
char c[maxn][maxn];
bool vis[maxn][maxn];
int q[maxt][2];
const int INF=0x3f3f3f3f;
const int MAX_V=50050;
struct edge{
    int to,cap,rev;
    edge(int _to,int _cap,int _rev):to(_to),cap(_cap),rev(_rev){}
};
vector<edge>G[MAX_V];
int level[MAX_V];
int iter[MAX_V];
void add_edge(int from,int to,int cap)
{
    G[from].push_back(edge(to,cap,G[to].size()));
    G[to].push_back(edge(from,0,G[from].size()-1));
}
void bfs(int s)
{
    memset(level,-1,sizeof(level));
    queue<int>que;
    level[s]=0;
    que.push(s);
    while(!que.empty()){
        int v=que.front();que.pop();
        for(int i=0;i<G[v].size();i++){
            edge &e=G[v][i];
            if(e.cap>0&&level[e.to]<0){
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}
int dfs(int v,int t,int f)
{
    if(v==t){
        return f;
    }
    for(int &i=iter[v];i<G[v].size();i++){
        edge &e=G[v][i];
        if(e.cap>0&&level[v]<level[e.to]){
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t)
{
    int flow=0;
    for(;;){
        bfs(s);
        if(level[t]<0){
            return flow;
        }
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,INF))>0){
            flow+=f;
        }
    }
    return flow;
}
void BFS(int k,int x,int y)
{
    memset(vis,false,sizeof(vis));
    int s=0,t=1;
    vis[x][y]=true;dis[k][x][y]=0;vis[x][y]=true;
    q[s][0]=x;q[s][1]=y;
    while(s<t){
        for(int i=0;i<4;i++){
            int tx=q[s][0]+dx[i],ty=q[s][1]+dy[i];
            if(tx<1||tx>n||ty<1||ty>m||vis[tx][ty]||c[tx][ty]!='.')continue;
 
            dis[k][tx][ty]=dis[k][q[s][0]][q[s][1]]+1;
            q[t][0]=tx;q[t][1]=ty;t++;vis[tx][ty]=true;
        }
        s++;
    }
}
inline bool judge(int mi)
{
    src=0;des=R+E*mi+1;
    for(int i=0;i<=des;i++)G[i].clear();
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(c[i][j]=='.')add_edge(src,GG[i][j],1);
        }
    }
    for(int k=1;k<=E;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(c[i][j]=='.'&&dis[k][i][j]<=mi)add_edge(GG[i][j],(k-1)*mi+R+dis[k][i][j],1);
            }
        }
    }
    for(int i=1;i<=E;i++){
        for(int j=1;j<=mi;j++){
            int tmp=(i-1)*mi+R;add_edge(tmp+j,des,1);
            if(j!=mi)add_edge(tmp+j,tmp+j+1,inf);
        }
    }
    return max_flow(src,des)==R;
}
int main()
{
    memset(dis,inf,sizeof(dis));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%s",c[i]+1);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(c[i][j]=='D')BFS(++E,i,j);
            else if(c[i][j]=='.')GG[i][j]=++R;
        }
    }
    int l=0,r=1000;
    while(l+1<r){
        int mid=(l+r)>>1;
        if(judge(mid))r=mid;
        else l=mid;
    }
    if(r==1000)printf("impossible\n");
    else printf("%d\n",r);
    return 0;
}

还有一个不用vector的dinic版：

#include<bits/stdc++.h>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxn=20+5;
const int maxt=5e4+5;
const int dx[]={-1,1,0,0},dy[]={0,0,-1,1};
int n,m,E,R,GG[maxn][maxn],dis[100][maxn][maxn],src,des;
char c[maxn][maxn];
bool vis[maxn][maxn];
int q[maxt][2];
const int INF=0x3f3f3f3f;
const int MAX_V=50050;
int level[MAX_V];
int iter[MAX_V];
struct edge{int v,w,next;}e[1000000];
int head[50050],tot=1;
void add_edge(int u,int v,int w)
{
    e[++tot].v=v;e[tot].w=w;e[tot].next=head[u];head[u]=tot;
    e[++tot].v=u;e[tot].w=0;e[tot].next=head[v];head[v]=tot;
}
void bfs(int s)
{
    for(int i=src;i<=des;i++)iter[i]=head[i],level[i]=-1;
    queue<int>que;
    level[s]=0;
    que.push(s);
    while(!que.empty()){
        int v=que.front();que.pop();
        for(int i=head[v];i;i=e[i].next){
            if(e[i].w>0&&level[e[i].v]<0){
                level[e[i].v]=level[v]+1;
                que.push(e[i].v);
            }
        }
    }
}
int dfs(int v,int t,int f)
{
    if(v==t)return f;
    for(int &i=iter[v];i;i=e[i].next){
        if(e[i].w>0&&level[v]<level[e[i].v]){
            int d=dfs(e[i].v,t,min(f,e[i].w));
            if(d){
                e[i].w-=d;
                e[i^1].w+=d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t)
{
    int flow=0;
    for(;;){
        bfs(s);
        if(level[t]<0)return flow;
        int f;
        while(f=dfs(s,t,INF)>0){
            flow+=f;
        }
    }
    return flow;
}
void BFS(int k,int x,int y)
{
    memset(vis,false,sizeof(vis));
    int s=0,t=1;
    vis[x][y]=true;dis[k][x][y]=0;vis[x][y]=true;
    q[s][0]=x;q[s][1]=y;
    while(s<t){
        for(int i=0;i<4;i++){
            int tx=q[s][0]+dx[i],ty=q[s][1]+dy[i];
            if(tx<1||tx>n||ty<1||ty>m||vis[tx][ty]||c[tx][ty]!='.')continue;

            dis[k][tx][ty]=dis[k][q[s][0]][q[s][1]]+1;
            q[t][0]=tx;q[t][1]=ty;t++;vis[tx][ty]=true;
        }
        s++;
    }
}
inline bool judge(int mi)
{
    src=0;des=R+E*mi+1;
    memset(head,0,sizeof(head));tot=1;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(c[i][j]=='.')add_edge(src,GG[i][j],1);
        }
    }
    for(int k=1;k<=E;k++){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(c[i][j]=='.'&&dis[k][i][j]<=mi)add_edge(GG[i][j],(k-1)*mi+R+dis[k][i][j],1);
            }
        }
    }
    for(int i=1;i<=E;i++){
        for(int j=1;j<=mi;j++){
            int tmp=(i-1)*mi+R;add_edge(tmp+j,des,1);
            if(j!=mi)add_edge(tmp+j,tmp+j+1,inf);
        }
    }
    return max_flow(src,des)==R;
}
int main()
{
    memset(dis,inf,sizeof(dis));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)scanf("%s",c[i]+1);
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(c[i][j]=='D')BFS(++E,i,j);
            else if(c[i][j]=='.')GG[i][j]=++R;
        }
    }
    int l=0,r=1000;
    while(l+1<r){
        int mid=(l+r)>>1;
        if(judge(mid))r=mid;
        else l=mid;
    }
    if(r==1000)printf("impossible\n");
    else printf("%d\n",r);
    return 0;
}

 

肘子zhouzi
关注
BZOJ 1189: [HNOI2007]紧急疏散evacuate 二分+最大流
dilu0653的博客
08-08 107
title BZOJ 1189 LUOGU 3191 Description 发生了火警，所有人员需要紧急疏散！假设每个房间是一个N M的矩形区域。每个格子如果是'.'，那么表示这是一块空地；如果是'X'，那么表示这是一面墙，如果是'D'，那么表示这是一扇门，人们可以从这儿撤出房间。已知门一定在房间的边界上，并且边界上不会有空地。最初，每块空地上都有一个人，在疏散的时候，每一秒钟每个人...
BZOJ 1189 [HNOI2007]紧急疏散evacuate 二分+最大流
-Claude
10-20 1978
BZOJ 1189 [HNOI2007]紧急疏散evacuate 二分+最大流
BZOJ1189: [HNOI2007]紧急疏散evacuate 二分+最大流
weixin_30788239的博客
08-29 78
1189: [HNOI2007]紧急疏散evacuate Time Limit:10 SecMemory Limit:162 MBSubmit:1132Solved:412[Submit][Status][Discuss] Description 发生了火警，所有人员需要紧急疏散！假设每个房间是一个N M的矩形区域。每个格子如果是'.'，那么表示这是一块空地；如果是'...
BZOJ 1189 HNOI2007 紧急疏散evacuate 二分答案+最大流
世界
11-29 2091
题目大意：给定一个m*n的地图，每个点有可能是空地、墙或者出口，每个空地初始站着一个人，每一时刻可以向周围走1格，门每一时刻只能通过一个人，求最短多少时间后所有人可以撤离 首先从每个出口出发开始广搜，得到每个空地到所有出口的距离 然后二分答案，每次建图如下： 从源点向每个空地一条流量为1的边 如果一个空地能在规定时间到达某个出口，就从这个空地出发向该出口链接一条流量为1的边 每个出口向汇
bzoj 1189: [HNOI2007]紧急疏散evacuate 分层图最大流 + 拆点 + 二分
EM LGH
05-18 71
Description 发生了火警，所有人员需要紧急疏散！假设每个房间是一个N M的矩形区域。每个格子如果是'.'，那么表示这是一 块空地；如果是'X'，那么表示这是一面墙，如果是'D'，那么表示这是一扇门，人们可以从这儿撤出房间。已知门 一定在房间的边界上，并且边界上不会有空地。最初，每块空地上都有一个人，在疏散的时候，每一秒钟每个人都 可以向上下左右四个方向移动一格，当然...
bzoj 1189 [HNOI2007]紧急疏散evacuate 二分+网络流
weixin_30477797的博客
04-14 79
[HNOI2007]紧急疏散evacuate Time Limit:10 SecMemory Limit:128 MBSubmit:3626Solved:1059[Submit][Status][Discuss] Description 发生了火警，所有人员需要紧急疏散！假设每个房间是一个N M的矩形区域。每个格子如果是'.'，那么表示这是一 块空地；如果是'X'，...
BZOJ1189 HNOI2007 紧急疏散evacuate 网络流+BFS+二分法
a18700013354的博客
02-28 93
题意：一个N M的矩形区域。格子如果是'.'，那么表示这是一块空地；如果是'X'，那么表示这是一面墙，如果是'D'，那么表示这是一扇门，人们可以从这儿撤出房间。已知门一定在房间的边界上，并且边界上不会有空地。每块空地上都有一个人，在疏散的时候，每一秒钟每个人都可以向上下左右四个方向移动一格，当然他也可以站着不动。疏散开始后，每块空地上就没有人数限制。每一秒钟只能有一个人移动到门的位置，一...
bzoj 1189: [HNOI2007]紧急疏散evacuate 分层图最大流_拆点_二分
EM LGH
05-18 132
bzoj 1189: [HNOI2007]紧急疏散evacuate 分层图最大流_拆点_二分 Code: #include<bits/stdc++.h> #define setIO(s) freopen(s".in","r",stdin) #define maxn 100000 #define inf 100000 ...
【BZOJ1189】【HNOI2007】紧急疏散evacuate 二分答案+最大流check
辗转山河弋流歌
02-09 1897
题解： 首先floyd或者bfs求出每个'.'到各个'D'的最短路 然后注意一个点不能经过一个门去另一个门，所以可以看到我的floyd略有一点点点点不同。。。 然后这个时间限制可以转化为对每个门的拆点，可以证明拆400个就够了。 然后分别对应每个时间可以出去一个人， 而这样在二分时重建图也是很方便的， 代码： #include #include #include
【BZOJ1189】【HNOI2007】紧急疏散evacuate
cz_xuyixuan的博客
01-12 435
【题目链接】 点击打开链接 【思路要点】 问题中存在一种类似于流量限制的人流限制，考虑用网络流解决本题。枚举答案，对于每个时刻的每个位置分别建立一个点，简单建图后运行最大流，观察是否满流即可。常见的网络流\(Dinic\)算法中建立了反向边，因此可以在\(Ans=x\)的残量网络上加点后直接继续运行\(Ans=x+1\)的结果。最终图中的点数与边数均为\(
bzoj1734：愤怒的牛：二分答案+贪心（入门题）
liusu201601的博客
02-06 1053
昨天刷一道单调队列的题目，被二分卡住了，所以打算认真刷一波二分，必须把细节都搞透，这是T1； 题目连接： BZOJ1734  LOJ10011 题目大意： 1 在n个数字中，选择m个，要求彼此间隔相同，并且尽可能远； 解题思路：经典二分答案 1 对于数列进行排序： 2 二分答案：用贪心来判断合法与否； 3 因为二分答案一般都是有极值的，所以比较简单，后面的二分查找会比较恶心 上代码...
bzoj3784: 树上的路径（二分答案+点分治）
苟为蒟蒻又何妨
01-20 602
传送门 点分治好题。 题意简述：给一棵带边权的树，问所有路径中前mmm大的。m≤300000m\le300000m≤300000 思路： 网上有题解写了可以通过什么点分治序转化成超级钢琴那道题的做法蒟蒻吓得瑟瑟发抖。 然后由于我比较菜想了一个二分答案的方法。 我们二分第mmm大的值，每次用点分治检验合法性。 二分完了之后我们再跑一次点分统计答案。 然后第一个二分的时候直接做是logn3log^3...
BZOJ 1997: [Hnoi2010]Planar|2-SAT|二分图染色
ws_yzy的博客
01-07 973
一道比较奇怪的题 用二分图染色和2-SAT都可以建模 想了一下为什么 二分图染色是找出矛盾的关系连边 2-SAT是找出“必须”的关系连边 而此题恰好都满足 -------------------------------------------------- 2-SAT做法： 一组边a,b在环构成的圆内相交 那么在圆外的a‘,b'也相交 ”必须“关系有 a-->b'   a'-->
BZOJ 4311: 向量（线段树分治+凸包+三分）
Ab.Ever
11-05 577
Description你要维护一个向量集合，支持以下操作： 1.插入一个向量(x,y) 2.删除插入的第i个向量 3.查询当前集合与(x,y)点积的最大值是多少。如果当前是空集输出0Input第一行输入一个整数n，表示操作个数 接下来n行，每行先是一个整数t表示类型，如果t=1，输入向量 (x,y)；如果t=2，输入id表示删除第id个向量；否则输入(x,y)，查询 与向量(x,y)点积
OBS-Studio-30.2.3-Windows.zip
最新发布
09-23
OBS-Studio-30.2.3-Windows.zip
ChanjeeDlnaTool-v1.0 推送电脑上的文件到安卓电视大屏，实现音视频播放和apk安装
09-23
详情参考：https://blog.csdn.net/title71/article/details/142462255?spm=1001.2014.3001.5501 文件里面含有视频使用教程 一.windows+Android大屏 使用投送教程： 准备 0.电视机和电脑要在同一网络下面 1.使用u盘安装chanjeeDlnaTool.apk到电视机 2.将Windows软件拷贝到合适目录，将.mp4 /.flac /.jpg ...文件拷贝到软件目录的www/files文件夹下面 投送 1.打开Android电视机大屏的刚安装的软件，找到左上角显示的电视机的ip地址 2.双击打开Windows软件的ChanjeeDlnaTool.exe文件，有弹窗提示防火墙网络，请点击允许 3.在Windows软件的ip地址栏输入Android电视机大屏上面的ip地址，并在Windows软件点击认证 4.认证完成后Windows软件下方蓝字会提示Binging successful 就说明绑定成功，此时就可以在Windows软件选择本地文件向Android大屏投送文件了
CODESYS是PLC软件编程工具.docx
09-23
CODESYS是一款功能强大的PLC（可编程逻辑控制器）软件编程工具，广泛应用于工业自动化领域。以下是对CODESYS的详细介绍： 一、基本概述 定义：CODESYS是Controlled Development System的缩写，是可编程逻辑控制PLC的完整开发环境。 开发商：CODESYS软件商是德国Smart software solution GmbH，该公司位于德国巴伐利亚州肯普腾市。 最新版本：CODESYS V3（国内PLC用户使用的版本多为CODESYS V2.3）。V3版本在软件架构上有了很大的改善，朝安全软件的方向发展，正在申请TUV关于EN 61508的SIL认证。 二、主要特点 开放性：CODESYS是一个开放的软件平台，允许第三方开发者在其上开发定制化的解决方案，适应不同厂商的PLC设备，具有很高的灵活性和扩展性。 跨平台：CODESYS可以运行在多种不同的操作系统上，包括Windows、Linux和嵌入式系统（RTOS），提高了开发效率和可移植性。 多语言支持：支持IEC61131-3标准下的IL、ST、FBD、LD、CFC、SFC六种PLC编程语言，用
广西中医药大学在湖南2021-2024各专业最低录取分数及位次表.pdf
09-23
全国各大学在湖南2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
BZOJ2194: 快速傅立叶之二 (FFT)
05-12
这是一道经典的FFT模板题目，需要你掌握FFT的基本原理和实现。 FFT（快速傅里叶变换）是一种用于计算离散傅里叶变换（DFT）的算法。它将DFT的时间复杂度从O(N^2)降低到了O(N*logN)，因此在处理大规模数据时具有很高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值