HDU 3036 Escape 网格图多人逃生 网络流||二分匹配 建图技巧

最新推荐文章于 2018-08-11 11:10:48 发布
最新推荐文章于 2018-08-11 11:10:48 发布
阅读量2.1k 收藏
点赞数
分类专栏： 二分图相关 网络流 =======图论=======
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/acmmmm/article/details/24936553
版权

题意：

每个' . '有一个姑娘， E是出口，'.'是空地 , 'X‘ 是墙。

每秒钟每个姑娘可以走一步（上下左右）

每秒钟每个出口只能出去一个人

给定n*m的地图， 时限T

问所有姑娘能否在T秒内逃生，若能输出最小值，不能输出"impossible"

思路：

显然是二分答案+网络流判可行。

因为每个出口每秒钟只能出去一个人，那么就把每个出口按时间拆点，则T秒钟就拆成T个点。


网络流建图

1、源点 到 每个姑娘 建流量为1的边。

2、若某姑娘到 a出口需要时间为 t秒，则建一条流量为1的边 连向a出口拆点为t秒的点。

3、每个出口的所有拆点向汇点连一条流量为1的边。

4、对于每个出口u的x秒拆点，向u的x+1秒的拆点连一条流量为inf的边（表示从x秒来的人如果x秒还从u出不去，可以在u等到x+1秒出去）


二分一下 第二点中的 t 秒(即答案），判断最大流是否等于人数


二分匹配建图：

枚举时间（因为时间最大只有12*12）

在原图的基础上加上下面的边：

在i时间内若能出去则那姑娘向所有能出去的 出口时间拆点连边。

再在原来的匹配上继续增广，累计最大匹配数。

当最大匹配数==人数时则是最小的时间。


数据较水可以用点非主流的建图卡过去，估计只有30组数据。


网络流代码：

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;

#define ll int 

#define N 20050
#define M 105000
#define inf 10737418
struct Edge{  
	ll from, to, cap, nex;  
}edge[M*4];//注意这个一定要够大 不然会re 还有反向弧  

ll head[N], edgenum;  
void add(ll u, ll v, ll cap){  
	Edge E = { u, v, cap, head[u]};  
	edge[ edgenum ] = E;  
	head[u] = edgenum ++;

	Edge E2= { v, u, 0,   head[v]};  
	edge[ edgenum ] = E2;  
	head[v] = edgenum ++;  
}  
ll sign[N];  
bool BFS(ll from, ll to){  
	memset(sign, -1, sizeof(sign));  
	sign[from] = 0;  

	queue<ll>q;  
	q.push(from);  
	while( !q.empty() ){  
		int u = q.front(); q.pop();  
		for(ll i = head[u]; i!=-1; i = edge[i].nex)  
		{  
			ll v = edge[i].to;  
			if(sign[v]==-1 && edge[i].cap)  
			{  
				sign[v] = sign[u] + 1, q.push(v);  
				if(sign[to] != -1)return true;  
			}  
		}  
	}  
	return false;  
}  
ll Stack[N], top, cur[N];  
ll dinic(ll from, ll to){
	ll ans = 0;  
	while( BFS(from, to) )  
	{  
		memcpy(cur, head, sizeof(head));  
		ll u = from;      top = 0;  
		while(1)  
		{  
			if(u == to)  
			{  
				ll flow = inf, loc;//loc 表示 Stack 中 cap 最小的边  
				for(ll i = 0; i < top; i++)  
					if(flow > edge[ Stack[i] ].cap)  
					{  
						flow = edge[Stack[i]].cap;  
						loc = i;  
					}  

					for(ll i = 0; i < top; i++)  
					{  
						edge[ Stack[i] ].cap -= flow;  
						edge[Stack[i]^1].cap += flow;  
					}  
					ans += flow;  
					top = loc;  
					u = edge[Stack[top]].from;  
			}  
			for(ll i = cur[u]; i!=-1; cur[u] = i = edge[i].nex)//cur[u] 表示u所在能增广的边的下标  
				if(edge[i].cap && (sign[u] + 1 == sign[ edge[i].to ]))break;  
			if(cur[u] != -1)  
			{  
				Stack[top++] = cur[u];  
				u = edge[ cur[u] ].to;  
			}  
			else  
			{  
				if( top == 0 )break;  
				sign[u] = -1;  
				u = edge[ Stack[--top] ].from;  
			}  
		}  
	}  
	return ans;  
}  

void init(){memset(head,-1,sizeof head);edgenum = 0;}

char mp[15][15];
int n, m, T;
int Hash(int x,int y){return x*m+y;}

vector<int>E,P;
int dis[150][150], step[4][2]={1,0,-1,0,0,1,0,-1};
bool vis[150][150];
void bfs(int sx,int sy){
	int start = Hash(sx,sy);
	memset(vis, 0, sizeof vis);
	vis[sx][sy] = 1;
	dis[start][start] = 0;
	queue<int>qx,qy;	while(!qx.empty())qx.pop(); while(!qy.empty())qy.pop();
	qx.push(sx), qy.push(sy);
	while(!qx.empty()){
		int x = qx.front(), y = qy.front();
		qx.pop(); qy.pop();
		for(int i = 0; i < 4; i++){
			int dx = x + step[i][0], dy = y + step[i][1];
			if(!(0<=dx&&dx<n&&0<=dy&&dy<m))continue;
			if(vis[dx][dy] || mp[dx][dy]!='.')continue;
			vis[dx][dy] = 1;
			dis[Hash(dx,dy)][start] = dis[start][Hash(dx,dy)] = dis[start][Hash(x,y)]+1;
			qx.push(dx); qy.push(dy);
		}
	}
}
bool ok(int TIME){
	init();
	int from = N-2, to = N-1;
	for(int i = 0; i < P.size(); i++)add(from, P[i], 1);
	for(int i = 0; i < P.size(); i++)
	{
		for(int j = 0; j < E.size(); j++)
			if(dis[P[i]][E[j]]<=TIME)	add(P[i],j*150+150+dis[P[i]][E[j]],1);
	}
	for(int i = 0; i < E.size(); i++)
		for(int j = 1; j <= TIME; j++) 
		{
			add(i*150+150+j, to, 1);
			if(j!=TIME)
				add(i*150+150+j,i*150+150+j+1,inf);
		}
	return dinic(from,to)==P.size();
}
int main(){
	//freopen("date.in","r+",stdin);
	//freopen("ans.out","w+",stdout);

	int i, j;
	while(~scanf("%d %d %d",&n,&m,&T)){
		E.clear(); P.clear();
		memset(dis, 0, sizeof dis);
		memset(mp, 0, sizeof mp);
		for(i=0;i<n;i++)scanf("%s",mp[i]);
		

		for(i=0;i<n;i++)for(j=0;j<m;j++)
		{
			if(mp[i][j]=='E')E.push_back(Hash(i,j));
			else if(mp[i][j]=='.')P.push_back(Hash(i,j));
		}
		if(P.size()==0){puts("0");continue;}	if(E.size()==0){puts("impossible");continue;}

		for(i = 0; i < E.size(); i++)bfs(E[i]/m, E[i]%m);
		int l = 1, r = 256, ans = inf;
		while(l<=r)
		{
			int mid = (l+r)>>1;
			if(ok(mid))ans = min(ans, mid), r = mid-1;
			else l = mid+1;
		}
		if(T<ans || ans==inf){puts("impossible");continue;}
		else printf("%d\n",ans);
	}
	return 0;
}
/*
6 12 100000
......E....E
E.EEE...E...
...E....EE..
.E.E.......E
.....E......
.E...E...EE.
11 3 100000
X..
...
.E.
EE.
E.E
...
...
.E.
E..
..E
E..
7 6 100000
.E..E.
...E..
......
...E.E
...X..
...EE.
....E.
11 10 100000
.E........
......E...
........E.
EE....E..E
...E...E..
......XE.E
..........
.........X
.........E
.EE.......
..EE.E.E.E
7 3 100000
...
..E
...
..X
EE.
...
.X.
3 2 100000
..
..
EE
6 7 100000
..E....
.......
.....E.
...EE..
.......
.......
6 8 100000
..EEEE..
...E....
........
........
.......E
E......E

10 8 100000
E.E..X..
........
E...E...
E..E....
........
.....E..
......EX
........
.E......
..E..EE.

5 5 100
.....
XXXXX
EEEEE
.....
XXXXX

1 1 1
E

1 1 1
P
1 1 1
X

2 2 1
E.
.X

2 2 2
E.
.X

8 1 1000
.
E
.
.
.
.
.
.

3 4 100
E...
....
...E

3 4 100
E...
.E..
...E

4 5 100
E....
.E...
...E.
.....

4 5 100
.....
.E...
.....
.....

12 12 10000000
...E.....E.E
E.E.E.....E.
.......E....
............
......E.....
............
...E.....E.E
E.E.E.....E.
.......E....
............
......E.....
............

12 12 6
...E.....E.E
E.E.E.....E.
.......E....
............
......E.....
............
...E.....E.E
E.E.E.....E.
.......E....
............
......E.....
............

12 12 10000000
E...........
............
............
............
............
............
............
............
............
............
............
............

12 12 10000000
E...........
............
............
............
............
.....E......
............
............
............
............
............
...........E

3 3 10
...
.E.
...

*/
二分匹配代码： 

#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

/* '0. Macros, Preprocessers, */
#pragma comment(linker, "/STACK:102400000,102400000")
#ifdef _WIN32
typedef __int64 int64;
#define OD(_TYPE) printf("%I64d\n", _TYPE)
#define ODC(_CASE, _TYPE) printf("Case %d: %I64d\n", _CASE++, _TYPE);
#else
typedef long long int64;
#define OD(_TYPE) printf("%lld\n", _TYPE)
#define ODC(_CASE, _TYPE) printf("Case %d: %lld\n", _CASE++, _TYPE);
#endif
#define LSON l,mid,id<<1
#define RSON mid+1,r,id<<1|1
#define MM (l+r)>>1

/* '1. Constants, */
const double EPS = 1e-8;
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;

/* '2. Coding Area, */
const int N = 15;
const int M = 205;
const int dir[4][2] = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 } };
struct STATE {
    int x, y, t;
    STATE() { }
    STATE(int x, int y, int t) : x(x), y(y), t(t) { }
};
int uN, vN;
vector<int> g[M];
int linker[M * M];  // 每个v对应的u匹配
bool used[M * M];
char mp[N][N];
int dis[M][M];  // 每个女孩到出口的最短时间
bool vis[N][N];  // 访问过或没有
int r, c, T;
int gid, eid;
map<pair<int, int>, int> mpg, mpe;  // 每个点的编号

bool dfs(int u) {
    for (unsigned int i = 0; i < g[u].size(); i++) {
        int v = g[u][i];
        if (used[v]) continue;
        used[v] = true;
        if (linker[v] == -1 || dfs(linker[v])) {
            linker[v] = u;
            return true;
        }
    }
    return false;
}

int hungary() {
    int res = 0;
    memset(linker, -1, sizeof(linker));
    for (int u = 0; u < uN; u++) {
        memset(used, 0, sizeof(used));
        if (dfs(u))
            ++res;
    }
    return res;
}

void bfs(int x, int y) {
    queue<STATE> q;
    int eid = mpe[make_pair(x, y)];
    memset(vis, 0, sizeof(vis));
    vis[x][y] = 1;
    q.push(STATE(x, y, 0));
    while (!q.empty()) {
        STATE now = q.front();
        q.pop();
        for (int i = 0; i < 4; i++) {
            int dx = now.x + dir[i][0];
            int dy = now.y + dir[i][1];
            if (dx >= 0 && dx < r && dy >= 0 && dy < c) {
                if (mp[dx][dy] != '.') continue;
                if (vis[dx][dy]) continue;
                int gid = mpg[make_pair(dx, dy)];
                q.push(STATE(dx, dy, now.t + 1));
                dis[gid][eid] = now.t + 1;
                vis[dx][dy] = 1;
            }
        }
    }
}

bool build_and_run(int limit) {
    for (int i = 0; i < M; i++) g[i].clear();
    uN = gid, vN = eid * limit;
    for (int i = 0; i < gid; i++) {
        for (int j = 0; j < eid; j++) {
            for (int k = dis[i][j]; k <= limit; k++) {
                g[i].push_back(j * limit + k);
            }
        }
    }
    int ans = hungary();
    if (ans >= gid) return true;
    return false;
}

void gao() {
    gid = eid = 0;
    mpg.clear(); mpe.clear();
    memset(dis, 0x3f, sizeof(dis));
    for (int i = 0; i < r; i++) {
        scanf("%s", mp[i]);
        for (int j = 0; j < c; j++) {
            if (mp[i][j] == 'E') mpe[make_pair(i, j)] = eid++;
            if (mp[i][j] == '.') mpg[make_pair(i, j)] = gid++;
        }
    }

    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
            if (mp[i][j] == 'E') {
                bfs(i, j);
            }
        }
    }

    int L = 1, R = 256, ans = INF;
    while (L <= R) {
        int mid = (L + R) >> 1;
        if (build_and_run(mid)) {
            ans = mid;
            R = mid - 1;
        } else {
            L = mid + 1;
        }
    }
    if (ans == INF || ans > T) {
        printf("impossible\n");
    } else {
        printf("%d\n", ans);
    }
}

int main() {
    while (~scanf("%d%d%d", &r, &c, &T)) {
        memset(g, 0, sizeof(g));
        gao();
    }
    return 0;
}



九野的博客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU二分匹配及其应用
07-10
HDU二分匹配及其应用，此PPT是刘春英老师版权所有， 特此贡献给广大编程爱好者，特别是对于ACMer
bzoj 1443: [JSOI2009]游戏Game （二分图博弈+网络流）
clover_hxy的博客
05-03 843
题目描述传送门题目大意：给出一个n*m的棋盘，有一些障碍点，先手选择一个点，然后后手可以移动到上下左右四个格子（不能是障碍点）。两人轮流移动，不能移动到已经到达过的位置，最后不能操作的人输。题解二分图博弈 特点：(1)博弈双方轮流进行操作 (2)博弈状态可以分成两类，分别对于匹配的X，Y集。任意合法决策使博弈状态改变 (3)任意状态不能重复到达 (4)不能操作的人输对于这道来说，从一个点只能
bzoj 1189 紧急疏散 网络流
Ren_Ivan的博客
07-29 550
二分答案，网络流判断 将每个门拆点，每个人连向每个门的dis~当前解 然后跑最大流，如果等于人数，即为可行解 #include #include #include #include #include #include #define pa pair #define N 405 #define inf 0x7fffffff using namespace std; int n,m,p,per=
地震逃生【网络流】
stoorz
08-11 345
题目大意： 有nnn个人要从111到nnn，每条路最多能过p[i]p[i]p[i]个人，求每次最多能过几个人，需要几次才能使全部人通过？ 思路： 很裸的最大流。源点连向点111，点nnn连向汇点，按照读入的数据建模，跑一边DinicDinicDinic即可。 代码： #include &amp;amp;amp;lt;iostream&amp;amp;amp;gt; #include &amp;amp;amp;lt;cstdio&
网络流-高效劝退
DJ的博客
12-24 458
网络流——高效劝退
杭电ACM HDU 2524 矩形A+B
gubojun的专栏
05-30 1545
矩形A + B Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3159    Accepted Submission(s): 2374 Problem Description 给你一个高为n ，宽为m列的网格，计算出
HDUACM2010版13二分匹配及其应用.ppt
09-15
HDUACM2010版13二分匹配及其应用.ppt
二分图匹配实例代码及整理
12-26
二分图匹配实例代码及整理 1、匈牙利算法 HDU 1150 #include #include #include using namespace std; int m,n,k; int vis[105]; int mpt[105][105]; int use[105]; int hungary(int x) { for(int i=1;i<m;i++)...
HDU杭电 计算机网络实验报告
03-11
压缩包包含十份报告，已经通过验收，实验内容：交换机、生成树、静态路由、NAT等完全根据教材实验要求
hdu杭电网络编程结课报告 聊天室
02-16
hdu杭电网络编程结课报告 聊天室
HDU 3036 拆点二分最大流
_rabbit的专栏
05-04 1036
Escape Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 584    Accepted Submission(s): 117 Problem Description R's girl friend D is on m
hdu 3036 Escape 网络流
amily05200的博客
05-06 70
转载== 题意：每个' . '有一个姑娘， E是出口，'.'是空地 , 'X‘ 是墙。 每秒钟每个姑娘可以走一步（上下左右） 每秒钟每个出口只能出去一个人 给定n*m的地图， 时限T 问所有姑娘能否在T秒内逃生，若能输出最小值，不能输出"impossible" 思路： 显然是二分答案+网络流判可行。 因为每个出口每秒钟只能出去一个人，那么就把每个出口按时间拆点，则T秒钟就拆成T个点。 ...
洛谷 P1343 地震逃生
weixin_30567225的博客
03-05 116
题目描述 汶川地震发生时，四川**中学正在上课，一看地震发生，老师们立刻带领x名学生逃跑，整个学校可以抽象地看成一个有向图，图中有n个点，m条边。1号点为教室，n号点为安全地带，每条边都只能容纳一定量的学生，超过楼就要倒塌，由于人数太多，校长决定让同学们分成几批逃生，只有第一批学生全部逃生完毕后，第二批学生才能从1号点出发逃生，现在请你帮校长算算，每批最多能运出多少个学生，x名学生分几批才能运完...
HDU 4975 A simple Gaussian elimination problem. 网络流+矩阵上的dp
九野的博客
08-21 2787
随机输出保平安啊 和hdu4888一个意思，先跑个网络流然后dp判可行。 ==n^3的dp过不了，所以把n改成200。 ==因为出题人没有把多解的情况放在200*200以外的矩阵。 #include #include #include #include #include using namespace std; const int MAX_N = 1207; const in
网络流模版
九野的博客
09-06 2506
九野的博客，转载请注明出处 ： http://blog.csdn.net/acmmmm/article/details/11199941 特别注意：若是需要双向边，则addedge中第二个edge(反向弧) 的cap应该为cap而不是0 如：http://acm.hdu.edu.cn/showproblem.php?pid=3870 (此题虽用网络流容易超时，但网络流的建图十分巧妙，要符合
网络流DINIC 递归版模版
九野的博客
03-06 2462
给定一个有向图（若是无向图，那么可以用两条有向边表示一条无向边），边有一个权值表示这条边上的流量， 形象一点：我们有n个城市，告诉你某些路以及路上最多分分钟的车流量。 然后我们求从 1 点压入无限多的车，问从n点分分钟能跑出多少车量的问题称为 网络流（最大流）。 我们称无限多进入车辆的点为：源点 车辆的出口的点为：汇点   数据结构：用以下这样的结构体来表示边 struct Edge
HDU 3549 Flow Problem(有向边网络流)
九野的博客
09-06 2396
题意：T个测试数据 下面n，m表示n个点m条有向带权边 m条边 问：从1-n最大流多少 测板子的题目，没啥思路 下面用的是dinic，开始没有考虑反向弧debug了好久，附赠一大坨测试数据 #include #include #include #include #include #include #include #include #include
HDU 3472 混合图欧拉回路 + 网络流
九野的博客
10-31 2349
题意： T个测试数据 n串字符 能否倒过来用(1表示能倒着用) 问能否把所有字符串 首尾相接    欧拉回路是图G中的一个回路，经过每条边有且仅一次，称该回路为欧拉回路。具有欧拉回路的图称为欧拉图，简称E图。    混合图就是边集中有有向边和无向边同时存在。这时候需要用网络流建模求解。 不能倒着用就是有向边，能倒着用就是无向边 http://yzmduncan.iteye.com
HDU4183 起点到终点再到起点 除起点每点仅经过一次 网络流
九野的博客
10-30 2278
题意： T个测试数据 n个圆 下面 fre x y r 表示圆的频率 坐标和半径 要求： 从频率为400(最小的) 圆 走到频率为789(最大)的圆，再走回来，除起点每个点只能经过一次 问这样的路径是否存在   走法：从400->789时经过的圆频率只增不减， 只能走相交的圆           反之则频率只减不增，也只能走相交的圆   建图： 以789为源点， 400为汇
hdu-1569(网络流)-最大点权独立集
最新发布
05-30
这是一道经典的网络流问题，可以使用最小割模型进行建模。 首先，将所有点拆成两个点，分别表示该点被选中和不被选中两种状态。对于每个点，如果它被选中，则将它的点权加入最终结果中。接下来，对于每条边 $(u,v)$...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值