poj2391(网络流+犀利建图)

最新推荐文章于 2018-08-06 10:12:37 发布
最新推荐文章于 2018-08-06 10:12:37 发布
阅读量731 收藏
点赞数
分类专栏： 图论 文章标签： 网络 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
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
极角排序:POJ 1696(叉积+深搜）
04-15
NULL 博文链接：https://128kj.iteye.com/blog/1750462
poj 2391(二分+最大流)
weixin_34326558的博客
08-23 101
题目链接：http://poj.org/problem?id=2391 思路：求最短时间,可以想到二分,然后判断可行性。首先在原图上求 floyd,得到每两个棚之间的最短距离。然后拆点:将每个棚拆为 i 和 i’(流进和流出),添边(i,i’,INF)。增加源点 s 和汇点 t,从 s 连边到 i,容量为该棚现在的猫的数量,i’连边到 t,容量为该棚的容量。若棚 i 和棚 j 之间的距离不大于 ...
POJ - 2391 最大流
weixin_34055787的博客
09-28 85
题目链接：http://poj.org/problem?id=2391 今天掉坑多次。 做了几道题，发现从源点出来的边和进入汇点的边都在题目中出来过。 POJ真是坑，交G++一直wa,检查代码检查了好几遍，无望看discuss，才知道交C++是RE，才知道数组越界了。 手写了Floyd，写成 i,j,k,wa了，突然想到以前遇到过这种问题。 看昂神解释明白了。 1 #in...
poj 2391
weixin_30914981的博客
12-16 76
又是网络流的建模.二分枚举答案。做这道题时，感觉做过类似的，想都没想就用之前的那个思路做了，结果错的。之前的思路就是，先求出任意两点间的最短路径，然后通过当前枚举的限制，把两点间路径在这个限制内的两点直接i连一条双向边。建s,t，s点到所有点连一条有向边，所有点到t连一条有向边。但这思路是错的，因为虽然在建的图中，任何从s到t的一个流的路径中的相临两点是在限制中，但这些满足限制的边可能经过组合就会...
POJ 2391 思维建图 + dinic + 二分
shadandeajian的博客
08-06 138
和POJ 2112的思路差不多，看见求最大时间的最小值，就是二分算法。然后每个点都有容量，就是拆点建边，自己加个源点和汇点，把每个避雨场拆成两个点，然后连有向图。 #include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;cstdio&gt; #include &lt;queue&gt; using namespace st...
poj2391 二分最大流+拆点
Frozensmile的博客
08-10 444
这道题范围开的非常的憋屈人  首先建立一个超级源点 编号是0 一个超级汇点 编号是2*f+1 将每个避雨点分成两个点 第一组编号为1～f 对应的第二组为f+1～2*f 每次建图 从源点向第一组每个避雨点连边 边的值为现在停留在这个点的牛的数量 从第二组每个点向汇点进行连边 边的值为这个点可容纳的牛的数量 然后对时间进行二分 如果从避雨点i走到避雨点j的时间小于等于mid 那么就从i到j
POJ1207-The 3n + 1 problem
07-29
北大POJ1207-The 3n + 1 problem 解题报告+AC代码
POJ.rar_poj java_poj1048
09-24
POJ1048，加强版的约瑟夫问题 难度中等
POJ2195-Going Home【费用流】
08-30
北大POJ2195-Going Home【费用流】 解题报告+AC代码 http://blog.csdn.net/lyy289065406/article/details/6732762
poj.rar_poj
09-20
POJ 上的近100道水题，基本涵盖了所有基本算法和数据结构，全部AC
POJ2391
FlushHip
08-01 633
Problem : Ombrophobic Bovines Description : 有N个点，每个点都有一些老鼠和一些能容纳老鼠的地方，现在，下午了，老鼠要在规定时间内都找到自己的容纳点，每个点到每个点都有一定的到达时间，现在问你最少要多少时间才能完成这项工作，如果不能完成，输出“-1”。 Solution : Floyd+二分枚举+网络最大流。这题是我的一个学习题。感觉网络流的应用真的是太
poj 2391(二分+拆点+最大流)
hexianhao的博客
06-03 371
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
【poj2391】Ombrophobic Bovines 二分+最大流+floyd
DQS的树洞
03-03 892
DescriptionFJ’s cows really hate getting wet so much that the mere thought of getting caught in the rain makes them shake in their hooves. They have decided to put a rain siren on the farm to let them
POJ 2391
Explorers
06-25 550
虽然这道题从网络流的角度来说不算难题，甚至是一道水题，但是还是足足卡了我3天啊，这是我学DINIC的diyig
【POJ2391】Ombrophobic Bovines【二分】【Floyd】【最大流】
BraketBN
04-04 516
【题目链接】 论文题，见【网络流建模汇总】。 注意： 1、要算最短路。 2、每次加边不能只加已经存在的边，而是枚举点，添加最短路径。 3、自己到自己也要连边。 4、注意Floyd要开long long。 5、注意判断-1。 数据地址：http://contest.usaco.org/MAR05_4.htm /* Pigonometry */ #includ
POJ--2391--Ombrophobic Bovines【拆点+Floyd+Dinic优化+二分答案】网络最大流
阳光照耀圣西罗
08-12 1205
链接：http://poj.org/problem?id=2391 题意：有f个草场，每个草场当前有一定数目的牛在吃草，下雨时它可以让一定数量的牛在这里避雨，f个草场间有m条路连接，每头牛通过一条路从一点到另一点有一定的时间花费，现在要下雨了，农场主发出警报牛就会立即去避雨。现在告诉每个草场的情况，以及m条边的信息。农场主至少需要提前多久发出警报才能保证所有牛都能避雨？如果不是所有牛都能成功避雨
POJ 2391 拆点+最大流+二分
huobengluantiao8
07-21 105
题意就不再说了，主要是想说一下为啥要拆点 POJ 2112跟本题很相似，也是二分，但它就没用拆点，本题就用了 为啥呢？ 因为POJ2112上建的图中是一个很明显的二分图，也就是左边的点绝对不会跟左边的点去连边的。而本题中就不一样了，任何点之间都可能有边。 会出现这种情况，1-&gt;2-&gt;3，这是一条链，而1-&gt;2最短路为1，2-&gt;3为1，1-&gt;3为 2，此时如果我们...
poj2391 二分+拆点+网络流
Shion的专栏
01-22 1418
题意： 有n个田地，给出每个田地上初始的牛的数量和每个田地可以容纳的牛的数量。 m条双向的路径，每条路径上可以同时通过的牛没有限制。 问牛要怎么走，能在最短时间内使得每块田地都能容纳的下，输出最短时间或-1。 思路： 先floyd求出任意两点之间的最短距离，然后二分答案，判断是否可以在时间不超过mid的情况下完成移动： 建图： 每个点拆成两个点x和x'，源点向x连边，权值为初
POJ2135 Farm Tour —— 最小费用最大流
最新发布
05-25
农夫约翰在他的农场里建立了一些水沟，以帮助水从一个地方流到另一个地方。他需要为这些水沟安排一些管道，以便水可以通过它们流动。然而，由于约翰的农场是非常大的，因此在不同位置的水沟之间建立管道的成本可能会...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值