poj2391(网络流+犀利建图)

最新推荐文章于 2018-11-27 09:27:56 发布
最新推荐文章于 2018-11-27 09:27:56 发布
阅读量753 收藏
点赞数
分类专栏： 图论 文章标签： 网络 rest struct build graph c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ysjjovo/article/details/6761661
版权

1.思路

首先是想了半天硬是没想出来，看了这个解题报告才知道建的图

然后是敲代码又范了很多错误，果然是逻辑思维不严密，基本功不扎实啊！加//的地方都是范过错误的地方，调了我整整一天啊！

用时还挺多的，没办法，二分求值，顺便用来比较一下各种算法的效率！

预流推进的居然TLE！，看样子代码还是写得不够好，不过有点好的是，移植性好，只要图建好后直接上模板！

2.代码(dinic)


#include <iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
#define N 420//双倍
#define M 500000//双倍
#define INF 100000000
#define MAX 1000000000000
struct Node{
    int u,v,next;
    int c;
};
struct Graph
{
    Node E[M];
    int first[N];
    int _V,_E,src,dest;
	int d[N];
	int num[N];
	int que[N],front,rear;
	int flow[N],cap[N];
	__int64 map[N][N];
	__int64 cost[N*N];
    void init(int n){
        _V=n,_E=0;
		src=0;dest=_V-1;
        memset(first,-1,4*_V);
    }
	void add(int u,int v,int c){
		E[_E].u=u,E[_E].v=v,E[_E].c=c,E[_E].next=first[u],first[u]=_E,_E++;
		E[_E].u=v,E[_E].v=u,E[_E].c=0,E[_E].next=first[v],first[v]=_E,_E++;
	}
	bool bfs()
	{
		memset(d,-1,4*_V);
		d[src]=0;
		front=rear=0;
		que[rear++]=src;
		while(front!=rear){
			int u=que[front++];
			for(int e=first[u];e!=-1;e=E[e].next){
				int v=E[e].v;
				if(d[v]==-1&&E[e].c){
					d[v]=d[u]+1;
					que[rear++]=v;
				}
				if(d[dest]!=-1)return true;
			}
		}
		return false;
	}
	int dfs(int u,int cap)
	{
		if(u==dest)return cap;
		int rest=cap,aug;
		for(int e=first[u];e!=-1&&rest;e=E[e].next){
			int v=E[e].v,c=E[e].c;
			if(d[v]==d[u]+1&&c){
				aug=dfs(v,rest>c?c:rest);
				rest-=aug;
				E[e].c-=aug;
				E[e^1].c+=aug;
			}
		}
		return cap-rest;
	}
	int dinic(){
		int flow=0;
		while(bfs())flow+=dfs(src,INF);
		return flow;
	}
	void display(){
        for(int i=0; i<_V; i++){
            for(int e=first[i]; e!=-1; e=E[e].next){
                int u=E[e].u,v=E[e].v;
				int c=E[e].c;
                cout<<u<<' '<<v<<' ';
				printf("%d\n",c);
            }
        }
    }
	void build(int n,__int64 limit)
	{
		init(2*n+2);
		int i,j;
		for(i=1;i<=n;i++)
		{
			if(flow[i])
			{
				add(i,i+n,INF);
				add(src,i,flow[i]);
			}
			if(cap)add(i+n,dest,cap[i]);
		}
		for(i=1;i<=n;i++)
			for(j=i+1;j<=n;j++)
				if(map[i][j]<=limit)
					add(i,j+n,INF),add(j,i+n,INF);//
	}
	__int64 solve(int n,int m)
	{
		int tot=0,tot2=0;
		int i,j,k;
		for(i=1;i<=n;i++)
		{
			scanf("%d%d",flow+i,cap+i);
			tot+=flow[i];
			tot2+=cap[i];
		}
		for(i=1;i<=n;i++)
		{
			fill(map[i],map[i]+1+n,MAX);
			map[i][i]=0;
		}
		
		int u,v,c;
		for(i=1;i<=m;i++)
		{
			scanf("%d%d%d",&u,&v,&c);
			if(c<map[u][v])map[u][v]=map[v][u]=c;
		}
		if(tot>tot2)return -1;
		for(k=1;k<=n;k++)
		{
			for(i=1;i<=n;i++)
			{
				for(j=1;j<=n;j++)
				{
					if(i==j)continue;
					__int64 t=map[i][k]+map[k][j];
					if(t<map[i][j])map[i][j]=t;	
				}
			}
		}
		int cnt;
		cost[cnt=1]=0;//
		
		for(i=1;i<=n;i++)
		{
			for(j=i+1;j<=n;j++)
				if(map[i][j]<MAX)cost[cnt++]=map[i][j];//
		}
		sort(cost+1,cost+cnt);
		for(i=1,j=1;i<cnt;i++){
			if(cost[i]==cost[j-1])continue;
			cost[j++]=cost[i];
		}
		int l=0,r=j-1,mid;
		while(l<=r)
		{
			mid=(l+r)>>1;
			build(n,cost[mid]);	
			if(dinic()==tot)
			{
				r=mid;//
				if(l==r)return cost[r];
			}
			else l=mid+1;
		}
		return -1;//
	}
}net;

int main()
{
#ifndef ONLINE_JUDGE
	freopen("data.in", "r", stdin);
#endif
    int n,m;
    while(cin>>n>>m)printf("%I64d\n",net.solve(n,m));//
	return 0;
}

2.sap 


#include <iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
#define N 420//双倍
#define M 500000//双倍
#define INF 100000000
#define MAX 1000000000000
struct Node{
    int u,v,next;
    int c;
};
struct Graph
{
    Node E[M];
    int first[N];
    int _V,_E,src,dest;
	int d[N];
	int num[N];
	int pre[N],cur,next;
	int flow[N],cap[N];
	__int64 map[N][N];
	__int64 cost[N*N];
    void init(int n){
        _V=n,_E=0;
		src=0;dest=_V-1;
        memset(first,-1,4*_V);
    }
	void add(int u,int v,int c){
		E[_E].u=u,E[_E].v=v,E[_E].c=c,E[_E].next=first[u],first[u]=_E,_E++;
		E[_E].u=v,E[_E].v=u,E[_E].c=0,E[_E].next=first[v],first[v]=_E,_E++;
	}
	inline bool advance(){
		for(int e=first[cur];e!=-1;e=E[e].next){
			if(d[cur]==d[E[e].v]+1&&E[e].c){
				pre[cur=E[e].v]=e;
				return true;
			}
		}
		return false;
	}
	inline int relable(){
		int mini=_V-1;
		for(int e=first[cur];e!=-1;e=E[e].next)if(E[e].c&&d[E[e].v]<mini)mini=d[E[e].v];
		return mini+1;
	}
	int sap(){
		memset(d,-1,4*_V);//!!!
		memset(num,0,4*_V);//
		pre[src]=-1;//!!!
		int flow=0,aug;

		while(d[src]!=_V){
			cur=src;
			while(cur!=dest){
				if(advance())continue;
				int lable=relable();
				num[d[cur]]--;num[d[cur]=lable]++;
				if( !num[d[cur]] || d[src]==_V )return flow;	
				if(cur!=src)cur=E[pre[cur]].u;//满足可行弧定义
			}
			aug=INF;
			int e=pre[dest],aug=INF;
			while(e!=-1)aug=aug<E[e].c?aug:E[e].c,e=pre[E[e].u];
			flow+=aug;e=pre[dest];
			while(e!=-1)E[e].c-=aug,E[e^1].c+=aug,e=pre[E[e].u];
		}
		return flow;
	}
	void build(int n,__int64 limit)
	{
		init(2*n+2);
		int i,j;
		for(i=1;i<=n;i++)
		{
			if(flow[i])
			{
				add(i,i+n,INF);
				add(src,i,flow[i]);
			}
			if(cap)add(i+n,dest,cap[i]);
		}
		for(i=1;i<=n;i++)
			for(j=i+1;j<=n;j++)
				if(map[i][j]<=limit)
					add(i,j+n,INF),add(j,i+n,INF);//
	}
	__int64 solve(int n,int m)
	{
		int tot=0,tot2=0;
		int i,j,k;
		for(i=1;i<=n;i++)
		{
			scanf("%d%d",flow+i,cap+i);
			tot+=flow[i];
			tot2+=cap[i];
		}
		for(i=1;i<=n;i++)
		{
			fill(map[i],map[i]+1+n,MAX);
			map[i][i]=0;
		}
		
		int u,v,c;
		for(i=1;i<=m;i++)
		{
			scanf("%d%d%d",&u,&v,&c);
			if(c<map[u][v])map[u][v]=map[v][u]=c;
		}
		if(tot>tot2)return -1;
		for(k=1;k<=n;k++)
		{
			for(i=1;i<=n;i++)
			{
				for(j=1;j<=n;j++)
				{
					if(i==j)continue;
					__int64 t=map[i][k]+map[k][j];
					if(t<map[i][j])map[i][j]=t;	
				}
			}
		}
		int cnt;
		cost[cnt=1]=0;//
		
		for(i=1;i<=n;i++)
		{
			for(j=i+1;j<=n;j++)
				if(map[i][j]<MAX)cost[cnt++]=map[i][j];//
		}
		sort(cost+1,cost+cnt);
		for(i=1,j=1;i<cnt;i++){
			if(cost[i]==cost[j-1])continue;
			cost[j++]=cost[i];
		}
		int l=0,r=j-1,mid;
		while(l<=r)
		{
			mid=(l+r)>>1;
			build(n,cost[mid]);	
			if(sap()==tot)
			{
				r=mid;//
				if(l==r)return cost[r];
			}
			else l=mid+1;
		}
		return -1;//
	}
}net;

int main()
{
#ifndef ONLINE_JUDGE
	freopen("data.in", "r", stdin);
#endif
    int n,m;
    while(cin>>n>>m)printf("%I64d\n",net.solve(n,m));//
	return 0;
}


3.预流推进


是代码写厥了？

#include <iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
using namespace std;
#define N 420//双倍
#define M 500000//双倍
#define INF 100000000
#define MAX 1000000000000
int d[N];
struct cmp{
    bool operator()(const int &u,const int &v)const{
        return d[u]<d[v];
    }
};
struct Node{
    int u,v,next;
    int c;
};
struct Graph
{
    Node E[M];
    int first[N];
    int _V,_E,src,dest;
    __int64 rest[N];
    int in[N];
    priority_queue<int,vector<int>,cmp> active;

	int flow[N],cap[N];
	__int64 map[N][N];
	__int64 cost[N*N];
    void init(int n){
        _V=n,_E=0;
		src=0;dest=_V-1;
        memset(first,-1,4*_V);
    }
	void add(int u,int v,int c){
		E[_E].u=u,E[_E].v=v,E[_E].c=c,E[_E].next=first[u],first[u]=_E,_E++;
		E[_E].u=v,E[_E].v=u,E[_E].c=0,E[_E].next=first[v],first[v]=_E,_E++;
	}
	void calHeight(){
        memset(d,-1,sizeof(d));
        d[dest]=0;
		int que[N],front,rear;
        front=rear=0;
        que[rear++]=dest;
        while(front!=rear){
            int v=que[front++],u;
            for(int e=first[v]; e!=-1; e=E[e].next){
                u=E[e].v;
                if(d[u]==-1){
                    d[u]=d[v]+1;
                    que[rear++]=u;
                }
            }
        }
    }
	void preprocess(){
        for(int i=0;i<_V;i++)rest[i]=in[i]=0;
        rest[src]=INF;active.push(src);
    }
    inline void push(int u){
        for(int e=first[u]; e!=-1&&rest[u]; e=E[e].next){
			int v=E[e].v,c=E[e].c;
            if(d[E[e].v]+1==d[u]&&E[e].c){
				int aug=rest[u]<c?rest[u]:c;//!!
				rest[v]+=aug,rest[u]-=aug,E[e].c-=aug,E[e^1].c+=aug;
				if(!in[v]&&v!=dest&&v!=src){
					active.push(v);
					in[v]=true;
				}
			}
        }
	}
	inline bool relable(int u){
		d[u]=_V-1;
		for(int e=first[u]; e!=-1; e=E[e].next)if(E[e].c&&d[u]>d[E[e].v])d[u]=d[E[e].v];
		d[u]++;
		return d[u]!=_V;
	}
	__int64 preFlowPush(){
		calHeight();
		preprocess();
		while(!active.empty()){//!!不记录s,t
			int u=active.top();
			push(u);//从点u进行推流
			if(rest[u]&&relable(u))continue;//可以继续推流
			active.pop();in[u]=false;//否则弹出队列
		}
		return rest[dest];
	}
	void display(){
		for(int i=0; i<_V; i++){
			for(int e=first[i]; e!=-1; e=E[e].next){
				int u=E[e].u,v=E[e].v,c=E[e].c;
				cout<<u<<' '<<v<<' '<<c<<endl;
			}
		}
	}
	void build(int n,__int64 limit)
	{
		init(2*n+2);
		int i,j;
		for(i=1;i<=n;i++)
		{
			if(flow[i])
			{
				add(i,i+n,INF);
				add(src,i,flow[i]);
			}
			if(cap)add(i+n,dest,cap[i]);
		}
		for(i=1;i<=n;i++)
			for(j=i+1;j<=n;j++)
				if(map[i][j]<=limit)
					add(i,j+n,INF),add(j,i+n,INF);//
	}
	__int64 solve(int n,int m)
	{
		int tot=0,tot2=0;
		int i,j,k;
		for(i=1;i<=n;i++)
		{
			scanf("%d%d",flow+i,cap+i);
			tot+=flow[i];
			tot2+=cap[i];
		}
		for(i=1;i<=n;i++)
		{
			fill(map[i],map[i]+1+n,MAX);
			map[i][i]=0;
		}
		
		int u,v,c;
		for(i=1;i<=m;i++)
		{
			scanf("%d%d%d",&u,&v,&c);
			if(c<map[u][v])map[u][v]=map[v][u]=c;
		}
		if(tot>tot2)return -1;
		for(k=1;k<=n;k++)
		{
			for(i=1;i<=n;i++)
			{
				for(j=1;j<=n;j++)
				{
					if(i==j)continue;
					__int64 t=map[i][k]+map[k][j];
					if(t<map[i][j])map[i][j]=t;	
				}
			}
		}
		int cnt;
		cost[cnt=1]=0;//
		
		for(i=1;i<=n;i++)
		{
			for(j=i+1;j<=n;j++)
				if(map[i][j]<MAX)cost[cnt++]=map[i][j];//
		}
		sort(cost+1,cost+cnt);
		for(i=1,j=1;i<cnt;i++){
			if(cost[i]==cost[j-1])continue;
			cost[j++]=cost[i];
		}
		int l=0,r=j-1,mid;
		while(l<=r)
		{
			mid=(l+r)>>1;
			build(n,cost[mid]);	
			if(preFlowPush()==tot)
			{
				r=mid;//
				if(l==r)return cost[r];
			}
			else l=mid+1;
		}
		return -1;//
	}
}net;

int main()
{
#ifndef ONLINE_JUDGE
	freopen("data.in", "r", stdin);
#endif
    int n,m;
    while(cin>>n>>m)printf("%I64d\n",net.solve(n,m));//
	return 0;
}



demo
关注
专栏目录
PIGS POJ - 1149 最大流（建图神题）
WA是一笔财富
04-29 358
传送门：POJ1149 正确建模方法： 这题说多了都是泪啊，连暴力建模方法都和大牛想的不一样，还傻X的想为什么连样例都过不了。。 说这题是建图神题是因为他用到了许多建图时的优化方法，建图的基本优化准则： 直到今天才接触到这些方法，实在是太弱了。。都不敢往外说自己是搞图论的。。 代码： //ISAP int #include #include #include
POJ-1724 Roads + Python （DFS）
xxdragon126的博客
01-09 2397
原题链接：1724 -- ROADS 参考资料：王子解救公主力扣 174. 地下城游戏 DFS + Python_xxdragon126的博客-CSDN博客 一问题描述： 从起始城市1到终止城市N，要求在路费ALL可控的情况下路程最短，返回最短路程。详见原题链接。 结题思路： ## 使用DFS: # 1 首先，将数据转化为嵌套的字典，以便于查找当前城市所能到达的所有城市，以及到达各城市所需的路径和路径。 # 2 然后，从起始点1开始，查找其邻接点城市，将每个城市作为初始点，进行dfs搜索 .
poj 2391
weixin_30914981的博客
12-16 101
又是网络流的建模.二分枚举答案。做这道题时，感觉做过类似的，想都没想就用之前的那个思路做了，结果错的。之前的思路就是，先求出任意两点间的最短路径，然后通过当前枚举的限制，把两点间路径在这个限制内的两点直接i连一条双向边。建s,t，s点到所有点连一条有向边，所有点到t连一条有向边。但这思路是错的，因为虽然在建的图中，任何从s到t的一个流的路径中的相临两点是在限制中，但这些满足限制的边可能经过组合就会...
poj 2391(二分+最大流)
weixin_34326558的博客
08-23 120
题目链接：http://poj.org/problem?id=2391 思路：求最短时间,可以想到二分,然后判断可行性。首先在原图上求 floyd,得到每两个棚之间的最短距离。然后拆点:将每个棚拆为 i 和 i’(流进和流出),添边(i,i’,INF)。增加源点 s 和汇点 t,从 s 连边到 i,容量为该棚现在的猫的数量,i’连边到 t,容量为该棚的容量。若棚 i 和棚 j 之间的距离不大于 ...
POJ2391
FlushHip
08-01 656
Problem : Ombrophobic Bovines Description : 有N个点，每个点都有一些老鼠和一些能容纳老鼠的地方，现在，下午了，老鼠要在规定时间内都找到自己的容纳点，每个点到每个点都有一定的到达时间，现在问你最少要多少时间才能完成这项工作，如果不能完成，输出“-1”。 Solution : Floyd+二分枚举+网络最大流。这题是我的一个学习题。感觉网络流的应用真的是太
POJ 2391
Explorers
06-25 589
虽然这道题从网络流的角度来说不算难题，甚至是一道水题，但是还是足足卡了我3天啊，这是我学DINIC的diyig
极角排序:POJ 1696(叉积+深搜）
04-15
在POJ 1696这个编程题目中，很可能需要解决与极角排序相关的问题。POJ（Problem Online Judge）是一个在线的编程竞赛平台，它提供了许多编程题目供参赛者解决，以提升编程能力和算法理解。 描述中提到的“叉积+深搜...
上下界网络流
04-16
"上下界网络流" 上下界网络流是一种特殊的网络流，边的流量有限制，必须在[down, up]的范围内。普通的网络流也是一种特殊的上下界网络流，只是每条边的流量限制为[0, cap]。上下界网络流可以分为两种：有源汇和无...
poj2391Ombrophobic Bovines(floyd+二分+拆点+最大流)
ophunter的专栏
09-10 1296
题目请戳这里 题目大意：n块草地，每块草地有一些牛，每块草地有雨棚，可以容纳一定量的牛。草地间有路，可以无限通过牛，牛通过某条路有一定的时间。现在求最短的时间让所有的牛都能到雨棚。 题目分析：最大流。题目给的是无向图，所以先跑一遍floyd，求出任意2块草地之间最少的时间。因为牛通过路的时间是累加的，所以要把无向图改成有向图，保证牛走某条路后时间是累加的。方法是拆点，将草地i拆成i和i+n
POJ2391 Ombrophobic Bovines
寒雨微凝's Blog
11-27 217
传送门 发现惊天大错误QAQ T上天然后发现自己的板子是假的QAQ 就是这一句 if(!cur) return flow; 我之前一直写的是break。。。 注意实际意义 我们的dep[x]=-1是当前已经流不满无法増广了所以才把它设为-1不再增广 而流满了表示还可以继续增广所以直接return 我以前一直写的假板子直到这个题T飞。。。一个爆哭。。。   回归正传 这个题...
poj 2391 Ombrophobic Bovines
kongming_acm的专栏
09-18 373
Description FJ's cows really hate getting wet so much that the mere thought of getting caught in the rain makes them shake in their hooves.
POJ 2391 Ombrophobic Bovines(二分+floyd+最大流)
code
08-26 1308
POJ 2391 Ombrophobic Bovines(最大流) http://poj.org/problem?id=2391 题意:        给定一个无向图，点i 处有Ai头牛，点i 处的牛棚能容纳Bi头牛，求一个最短时间T使得在T时间内所有的牛都能进到某一牛棚里去。（1 分析:        将每个点i 拆成两个点i’, i’’，连 边(s, i’, Ai), (i’’,
poj2391 Ombrophobic Bovines
云游code的博客
08-01 1527
这题是一道很好的最大流题目，题意是给定F个牛棚和P条路径，每条路径有一个权值，现在每个牛棚有一定的容量和牛数，因为牛棚牛数可能大于容量，所以要牛棚之间的牛要进行相互地移动，每移动一个距离就花费一单位的时间，求从开始移动到每头牛都移动到牛棚的最小时间 显然建模是从源点S连接每一个
POJ--2391--Ombrophobic Bovines【拆点+Floyd+Dinic优化+二分答案】网络最大流
阳光照耀圣西罗
08-12 1252
链接：http://poj.org/problem?id=2391 题意：有f个草场，每个草场当前有一定数目的牛在吃草，下雨时它可以让一定数量的牛在这里避雨，f个草场间有m条路连接，每头牛通过一条路从一点到另一点有一定的时间花费，现在要下雨了，农场主发出警报牛就会立即去避雨。现在告诉每个草场的情况，以及m条边的信息。农场主至少需要提前多久发出警报才能保证所有牛都能避雨？如果不是所有牛都能成功避雨
poj 2391(拆点 + 二分 + dinic)
水杯
09-23 827
说一下这个题吧。。刚开始的时候。。没想到分点。。想简单了： 认为一个field可以只剩下牛或者牛棚（两者都有可以相减）。。。然后超级源点跟牛之间建边。。超级汇点跟牛棚建边。。。。YY的挺好。。。可是明显是错的。。。看一下样例就可以发现错误了。。然后开始拆点。。。。结果。。之后wa
poj 2391(二分+拆点+最大流)
hexianhao的博客
06-03 400
Ombrophobic Bovines Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 17554   Accepted: 3846 Description FJ's cows really hate getting wet so much that the mer
POJ 2391 拆点+最大流+二分
huobengluantiao8
07-21 136
题意就不再说了，主要是想说一下为啥要拆点 POJ 2112跟本题很相似，也是二分，但它就没用拆点，本题就用了 为啥呢？ 因为POJ2112上建的图中是一个很明显的二分图，也就是左边的点绝对不会跟左边的点去连边的。而本题中就不一样了，任何点之间都可能有边。 会出现这种情况，1-&gt;2-&gt;3，这是一条链，而1-&gt;2最短路为1，2-&gt;3为1，1-&gt;3为 2，此时如果我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值