POJ 2391 Ombrophobic Bovines

最新推荐文章于 2019-10-06 08:16:46 发布
最新推荐文章于 2019-10-06 08:16:46 发布
阅读量508 收藏
点赞数
分类专栏： 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/speedcell4/article/details/12921429
版权

好题一枚，问最短多少时间能然牛都进入牛棚，理所应当地牛棚有容量限制。

同样容易想到最短时间是跑最远的那头牛需要的时间，最大值最小化，显而易见地二分了。然后就是建图的问题，这里需要拆点[trick 1]，看了题解领悟到拆点的作用不只是度限制，还可以有方向限制的作用，类似于包含了阶段维的DP。假设本来A可以到B，B可以到C，但是A不能到C，如果不拆点的话，A就可以通过B到C了。[trick 2]距离数值非常大，要long long才行，然后的然后我本来可以1A的结果烦了一个傻逼的错误，我的无解是在二分的函数里面判断的，我是打断让bin正确的时候更新ans，如果没有更新过说明从来没有找到过满足的解然后就输出-1，但是我开始的时候上界取大了，然后直接就出一个大于了10^9的mid，所以果断就-1不能了……

/*
 Author : Speedcell
 Update : 2013-10-16
Version : soppYcell 2.4
*/

#include <algorithm>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>

#include <map>
#include <set>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <vector>
#include <string>
#include <bitset>
#include <memory>
#include <complex>
#include <numeric>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <ctype.h>
#include <assert.h>
#include <locale.h>

using namespace std;

#pragma pack(4)

#ifndef __CONSTANT__
#define __CONSTANT__

typedef long long LONG;

const double pi = acos(-1.0);
const int   inf = 0x7f7f7f7f;
const LONG  INF = 0x7fffffffffffffffll;

const int go[8][2] = {{0,1},{0,-1},{1,0},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}};

#endif // __CONSTANT__

#ifndef __IO__
#define __IO__

inline bool RD(int    & a) {return scanf("%d",&a)!=EOF;}
inline bool RD(char   & a) {return scanf("%c",&a)!=EOF;}
inline bool RD(char   * a) {return scanf("%s", a)!=EOF;}
inline bool RD(double & a) {return scanf("%lf",&a)!=EOF;}
inline bool RD(LONG   & a) {return scanf("%I64d",&a)!=EOF;}

template<class T1> inline bool
    IN(T1 & a) {return RD(a);}
template<class T1,class T2> inline bool
    IN(T1 & a,T2 & b) {return RD(a)&&RD(b);}
template<class T1,class T2,class T3> inline bool
    IN(T1 & a,T2 & b,T3 & c) {return RD(a)&&RD(b)&&RD(c);}
template<class T1,class T2,class T3,class T4> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d) {return RD(a)&&RD(b)&&RD(c)&&RD(d);}
template<class T1,class T2,class T3,class T4,class T5> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e);}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e,T6 & f) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e)&&RD(f);}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline bool
    IN(T1 & a,T2 & b,T3 & c,T4 & d,T5 & e,T6 & f,T7 & g) {return RD(a)&&RD(b)&&RD(c)&&RD(d)&&RD(e)&&RD(f)&&RD(g);}

inline void PT(int      a) {printf("%d",a);}
inline void PT(char     a) {printf("%c",a);}
inline void PT(char   * a) {printf("%s",a);}
inline void PT(double   a) {printf("%f",a);}
inline void PT(unsigned a) {printf("%u",a);}
inline void PT(LONG     a) {printf("%I64d",a);}
inline void PT(string   a) {printf("%s",a.c_str());}
inline void PT(const char a[]) {printf("%s",a);}

template<class T1> inline void
    OT(T1 a) {PT(a);}
template<class T1,class T2> inline void
    OT(T1 a,T2 b) {PT(a),PT(' '),PT(b);}
template<class T1,class T2,class T3> inline void
    OT(T1 a,T2 b,T3 c) {PT(a),PT(' '),PT(b),PT(' '),PT(c);}
template<class T1,class T2,class T3,class T4> inline void
    OT(T1 a,T2 b,T3 c,T4 d) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d);}
template<class T1,class T2,class T3,class T4,class T5> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e);}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f);}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline void
    OT(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f,T7 g) {PT(a),PT(' '),PT(b),PT(' '),PT(c),PT(' '),PT(d),PT(' '),PT(e),PT(' '),PT(f),PT(' '),PT(g);}

template<class T1> inline void
    OL(T1 a) {OT(a),PT('\n');}
template<class T1,class T2> inline void
    OL(T1 a,T2 b) {OT(a,b),PT('\n');}
template<class T1,class T2,class T3> inline void
    OL(T1 a,T2 b,T3 c) {OT(a,b,c),PT('\n');}
template<class T1,class T2,class T3,class T4> inline void
    OL(T1 a,T2 b,T3 c,T4 d) {OT(a,b,c,d),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e) {OT(a,b,c,d,e),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5,class T6> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f) {OT(a,b,c,d,e,f),PT('\n');}
template<class T1,class T2,class T3,class T4,class T5,class T6,class T7> inline void
    OL(T1 a,T2 b,T3 c,T4 d,T5 e,T6 f,T7 g) {OT(a,b,c,d,e,f,g),PT('\n');}

#endif // __IO__

#ifndef __MACRO__
#define __MACRO__

#define ML(times) int tcase; IN(tcase); FOR(times,1,tcase)

#define FOR(i,a,b) for(int i=int(a),_##i=int(b);i<=_##i;i++)
#define DWN(i,b,a) for(int i=int(b),_##i=int(a);_##i<=i;i--)
#define ECH(i,u,pre,next) for(int i=int(pre[u]);i!=-1;i=int(next[i]))

#define MEM(a,v) memset(a,v,sizeof(a))
#define CLR(a,v) FOR(_i##a,0,sizeof(a)/sizeof(a[0])-1) a[_i##a]=v

#define LOOP(a,n)                                               \
    FOR(_i##a,0,(n)-1)                                          \
        OT(a[_i##a]),OT(_i##a!=__i##a?' ':'\n')
#define LOOP2(a,n,m)                                            \
    FOR(_i##a,0,(n)-1) FOR(_j##a,0,(m)-1)                       \
        OT(a[_i##a][_j##a]),OT(_j##a!=__j##a?' ':'\n')
#define LOOPG(G,n,pre,next)                                     \
    FOR(_i##a,0,(n)-1) ECH(_j##a,_i##a,pre,next)                \
        OL(_i##a,G[_j##a].v,G[_j##a].w)

#endif // __MACRO__

#ifndef __BIT__
#define __BIT__

template<class T> inline T lb(T i) {return i&-i;}
template<class T> inline T lc(T i) {return i<<1;}
template<class T> inline T rc(T i) {return i<<1|1;}
template<class T> inline T at(T a,int i) {return a& (T(1)<<i);}
template<class T> inline T nt(T a,int i) {return a^ (T(1)<<i);}
template<class T> inline T s1(T a,int i) {return a| (T(1)<<i);}
template<class T> inline T s0(T a,int i) {return a&~(T(1)<<i);}

#endif // __BIT__

#ifndef __COMPARER__
#define __COMPARER__

const double eps = 1e-8;

inline int cmp(double a,double b=0) {return fabs(b-a)<eps?0:((b-a)<eps?+1:-1);}
template<typename type> inline int cmp(type a,type b=0) {return a==b?0:(b<a?+1:-1);}

template<typename type> inline bool gt(type a,type b) {return cmp(a,b)> 0;}
template<typename type> inline bool ge(type a,type b) {return cmp(a,b)>=0;}
template<typename type> inline bool eq(type a,type b) {return cmp(a,b)==0;}
template<typename type> inline bool ne(type a,type b) {return cmp(a,b)!=0;}
template<typename type> inline bool le(type a,type b) {return cmp(a,b)<=0;}
template<typename type> inline bool ls(type a,type b) {return cmp(a,b)< 0;}

template<typename type> inline type smax(type a,type b) {return gt(a,b)?a:b;}
template<typename type> inline type smin(type a,type b) {return ls(a,b)?a:b;}

#endif // __COMPARER__

const int MAXV = 410;
const int MAXE = 360000;

struct node
{
	int v,w;
}G[MAXE];
int _index,pre[MAXV],next[MAXE];

inline void clear(void)
{
	_index=0;
	MEM(pre,-1);
}
inline void add(int u,int v,int w)
{
	G[_index].v=v;
	G[_index].w=w;
	next[_index]=pre[u];
	pre[u]=_index++;

	G[_index].v=u;
	G[_index].w=0;
	next[_index]=pre[v];
	pre[v]=_index++;
}

int dis[MAXV],gap[MAXV],curr[MAXV],prev[MAXV],head[MAXV];

inline int SAP(int src,int des,int n)
{
	int u=src,sum=0,cnt;
	memcpy(head,pre,MAXV-1);
	MEM(dis,0); MEM(gap,0); gap[0]=n;

	while(dis[src]!=n)
	{
		bool flag=false;
		for(int &i=head[u];i!=-1;i=next[i])
		{
			int v=G[i].v;
			int w=G[i].w;
			if(w&&dis[u]==dis[v]+1)
			{
				curr[v]=i;
				prev[v]=u;

				flag=true;
				u=v;

				break;
			}
		}
		if(flag)
		{
			if(u==des)
			{
				cnt=inf;
				for(int i=des;i!=src;i=prev[i])
				{
					cnt=smin(cnt,G[curr[i]].w);
				}
				for(int i=des;i!=src;i=prev[i])
				{
					G[curr[i]].w-=cnt;
					G[curr[i]^1].w+=cnt;
				}
				sum+=cnt;
				u=src;
			}
		}
		else
		{
			if(!--gap[dis[u]]) break;
			else
			{
				dis[u]=n;
				head[u]=pre[u];
				ECH(i,u,pre,next)
				{
					int v=G[i].v;
					int w=G[i].w;
					if(w) dis[u]=smin(dis[u],dis[v]+1);
				}
				gap[dis[u]]++;
				if(u!=src) u=prev[u];
			}
		}
	}

	return sum;
}

LONG w,a[MAXV][MAXV];
int n,m,u,v,x[MAXV],y[MAXV];

inline int in(int u)
{
	return u*2+2;
}
inline int out(int u)
{
	return u*2+3;
}

inline bool bin(LONG val)
{
	clear();
	FOR(i,0,n-1)
	{
		add(0,in(i),x[i]);
		add(out(i),1,y[i]);
	}
	FOR(i,0,n-1) FOR(j,0,n-1) if(a[i][j]<=val)
	{
		add(in(i),out(j),inf);
	}
	SAP(0,1,n*2+2);
	ECH(i,0,pre,next) if(G[i].w) return false;
	return true;
}
inline LONG solve(LONG l,LONG r)
{
	LONG mid,ans=-1;
	while(l<=r)
	{
		mid=(l+r)/2;
		if(bin(mid))
		{
			ans=mid;
			r=mid-1;
		}
		else l=mid+1;
	}
	return ans;
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("Ombrophobic Bovines.txt","r",stdin);
    #else
    #endif

    while(IN(n,m))
	{
		FOR(i,0,n-1) FOR(j,0,n-1) a[i][j]=INF;
		FOR(i,0,n-1) IN(x[i],y[i]),a[i][i]=0;
		FOR(i,0,m-1)
		{
			IN(u,v,w);
			a[u-1][v-1]=smin(a[u-1][v-1],w);
			a[v-1][u-1]=smin(a[v-1][u-1],w);
		}
		FOR(k,0,n-1) FOR(i,0,n-1) if(a[i][k]!=INF) FOR(j,0,n-1) if(a[k][j]!=INF)
		{
			a[i][j]=smin(a[i][j],a[i][k]+a[k][j]);
		}
		LONG L=INF,R=-INF;
		FOR(i,0,n-1) FOR(j,0,n-1) if(a[i][j]!=INF)
		{
			L=smin(L,a[i][j]);
			R=smax(R,a[i][j]);
		}
		OL(solve(L,R));
	}
    return 0;
}

Speedcell
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
北大POJ 1324.cpp
03-11
北大POJ第1324题（C++）
POJ2391 Ombrophobic Bovines
寒雨微凝's Blog
11-27 194
传送门 发现惊天大错误QAQ T上天然后发现自己的板子是假的QAQ 就是这一句 if(!cur) return flow; 我之前一直写的是break。。。 注意实际意义 我们的dep[x]=-1是当前已经流不满无法増广了所以才把它设为-1不再增广 而流满了表示还可以继续增广所以直接return 我以前一直写的假板子直到这个题T飞。。。一个爆哭。。。   回归正传 这个题...
poj2391Ombrophobic Bovines
zjy2015302395的博客
09-28 353
Floyd+二分+最大流（dinic）+拆点 貌似这样子显得很高端呢传送门大意：给定一个无向图，点 i 处有 Ai 头牛，点 i 处的牛棚能容纳 Bi 头牛，求一个最短时 间 T 使得在 T 时间内所有的牛都能进到某一牛棚里去。（1 <= N <= 200, 1 <= M <= 1500, 0 <= Ai <= 1000, 0 <= Bi <= 1000, 1 <= Dij <= 1,000,00
POJ 2391 Ombrophobic Bovines(二分+floyd+最大流)
code
08-26 1269
POJ 2391 Ombrophobic Bovines(最大流) http://poj.org/problem?id=2391 题意:        给定一个无向图，点i 处有Ai头牛，点i 处的牛棚能容纳Bi头牛，求一个最短时间T使得在T时间内所有的牛都能进到某一牛棚里去。（1 分析:        将每个点i 拆成两个点i’, i’’，连 边(s, i’, Ai), (i’’,
poj 2391 Ombrophobic Bovines
weixin_30907935的博客
05-28 60
#include<iostream> #include<cstring> #include<cstdio> #include<algorithm> #include<queue> using namespace std; typedef long long ll; inline int read(){ ...
poj2391 Ombrophobic Bovines
weixin_30746117的博客
03-17 51
Ombrophobic Bovines Time Limit:1000MS Memory Limit:65536K Total Submissions:20459 Accepted:4403 Description FJ's cows really hate getting wet so much that the ...
POJ 2391 Ombrophobic Bovines(二分+网络流)
llzhh的博客
09-13 192
题意：给出n个牛棚，一开始每个牛棚有一些牛，但是每个牛棚只能住下规定数量的牛，每个牛棚之间有路可以互相到达，但是要花费一些时间，问是否有办法使得所有牛都有牛棚住，如果有办法，输出最小的时间花费。 解法：因为是问时间花费，所以很容易就想到了二分上面。先跑一边floyd得到每个牛棚之间的花费时间，直接二分时间，不断建图即可。 代码如下： #include #include #include #i
poj 2391 Ombrophobic Bovines （网络流）
非确定有限状态自动机
02-04 566
这是一道很经典的网络流的题目。首先我们考虑假如我们的时间为无穷大。我们吧每个点拆成2个点 i和i' .。虚拟源点s和汇点t。对于每个点建边(s,i, a[i])  （i‘,t,ib[i]） 。 其中a[i]为给点有多少牛，b[i]为容量。i和j连通 建边 (i，j',inf);如果最大流==所有牛的个数，就可能装下所有的牛。那么现在我们考虑时间。假设最大时间为T.那么如果i到j的的最短时间>T，那
POJ 2391 Ombrophobic Bovines （Floyd + Dinic +二分）
anvt77205的博客
10-06 109
Ombrophobic Bovines Time Limit:1000MS Memory Limit:65536K Total Submissions:11651 Accepted:2586 Description FJ's cows really hate getting wet so much that the ...
Poj 2391 Ombrophobic Bovines【二分+最大流Dinic】
mengxiang000000
08-27 913
Ombrophobic Bovines Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 18040   Accepted: 3921 Description FJ's cows really hate getting wet so
poj.rar_poj
最新发布
09-23
标题中的"poj.rar_poj"暗示了这是一个与POJ（Programming Online Judge）相关的压缩文件，POJ是一个在线编程竞赛平台，主要供程序员们练习和提交算法解决方案。在这个压缩包中，很可能包含了用户在POJ上参与编程挑战...
POJ.rar_poj
09-19
【标题】"POJ.rar_poj" 指的是一份与编程竞赛相关的压缩文件，主要涉及POJ（Problem Overloading Judge）平台上的问题解答。POJ是一个在线的编程竞赛平台，它为参赛者提供了大量的算法题目进行练习和比赛，以提升...
PowerOJ 1736 飞行员配对方案问题
10-03 1008
拆点连边就好了，网络流水题…… /* Author : Speedcell Update : 2013-05-30 Version : soppYcell 2.2(a) */ #include #include #include #include #include #include #include #include #include #include #incl
HDU 3395 Special Fish
08-10 702
题意读错了，正解是每条鱼最多击别人一次，被别人攻击一次，由此定流量…… 再者，攻击和被攻击次数都是最多一次，并非卡死一定一次，所以可以绕过攻击边直接到汇点…… #include #include #include #include #include #include #include #include #include #include #include #incl
SPOJ NETADMIN Smart Network Administrator
10-21 604
保证满流的情况，最小化源点到制定点集上每条边的流量最大值。最小最大化问题惯用二分，SPOJ似乎很喜欢点标号乱搞？ /* Author : Speedcell Update : 2013-10-16 Version : soppYcell 2.4 */ #include #include #include #include #include #include #incl
SPOJ IM Intergalactic Map
10-21 592
从1出发经过2到达3，不走相同边，从2做源点，1、3合并为汇点看最大流是不是2就好了……点标号会坑爹，map处理…… /* Author : Speedcell Update : 2013-10-16 Version : soppYcell 2.4 */ #include #include #include #include #include #include #incl
ZOJ 3642 Just Another Information Sharing Problem
08-26 523
自己已经知道的就不要问啦！！！ 自己已经知道的就不要问啦！！！ 自己已经知道的就不要问啦！！！ 自己已经知道的就不要问啦！！！ 少加了一条边无限WA，比赛的时候交了31次…… #include #include #include #include #include #include #include #include #include #include
ZOJ 2760 How Many Shortest Path
10-21 509
最多多少条不想交的最短路，正反两次SPFA然后枚举边可以确定这条边在不在最短路上，在的话就在网络里加边，这里的不想交是指边不想交，所以容量限定为1就好了…… 那个s==t的时候输出inf，坑死我了…… /* Author : Speedcell Update : 2013-10-16 Version : soppYcell 2.4 */ #include #include #in

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值