上下界网络流初探

最新推荐文章于 2020-09-30 18:35:59 发布

DKFleet

最新推荐文章于 2020-09-30 18:35:59 发布

阅读量665

点赞数

分类专栏：算法文章标签： OI 算法网络流

本文链接：https://blog.csdn.net/DKFleet/article/details/42324325

版权

算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

看文章各种不明真相...

请教了一下iwtwiioi大牛...大致有个理解....

建模过程

1.拆边. 对于每一条给出的有向边(u,v,c,d) ,其中c指下界,d指上界,那么在实际的图中连三条只有上界没有下界的边:

(S,v,c) (u,T,c) (u,v,d-c) 其中S是超级源,T是超级汇.(不同于题目给出的源与汇)

一条是超级源连向边的终点.

第二条是边的起点连向超级汇.

第三条是原来的边更改了权值.

最后,从汇向源连一条没有上下界的边(如果题目给定了源与汇).

然后跑S到T的最大流,得出来的就是可行流.

再从源到汇跑一遍最大流,所得流量就是最大流.

PS:~~神犇们说可行流流量+第二遍最大流的流量才是真正的流量...~~

~~但是为什么我的程序正确答案直接就是第二遍最大流的流量呢..~~

发现原来是汇到源的那条边在搞鬼.....

第一遍可行流的流量一定等于汇到源那条边的流量(因为原图没有环,是环流就必定经过这条边)

那么第二遍跑最大流的时候,源会直接通过那条边给出与可行流相等的流量.

当然除去此边,那些权值为d-c的边的流量还是需要把可行流流量加上去才行.

常数优化

只要是个流量网络,那么重边必定可以合并成一条边(不是最小费)

按照上边的方法,每条原式边对应的实际边数是3.我们处理那些像(SuT)的路径(从超级源直接连向点u,又从u连向点超级汇),让它们最多连接S,T中的一个.

直接统计入度和出度最后再构造边即可.

原理(?)

严谨证明的不会(要滚去好好看图论啊喂)

根据iwtwiioi介绍的思路......

-我们想要把一条边的最小容量塞满....那么边的起点要能给出这么多流量,边的终点要能接受这么多流量.

-那么我们就直接从超级源给出流量看终点能不能接受.

-以及从起点接收流量看我们能不能得到这么多.

我的理解...

首先有源汇的上下界网络流能转变为无源汇的上下界网络流.

所以考虑无源汇的网络流.

注意到每个点的入流等于出流.

说明什么呢?

每一道流(流量为1)总是会构成一个圈,一个环流. 可行流就是由一些环流构成的.

怎么证明呢? 假设有一道流不是环流,那么它就有两个端点,假设它从点a流向点b.

想要这两个端点的入流量等于出流量,只能再多一道从b到a的流补成环流.

现在可行流就是一堆的环流了.

观察上边所说的拆边法,发现其实就是把环流转成了从S到T的许多许多流而已.......

比如有环(a,b,c,d,a),最后会拆成

(S,a,T) (S,b,T) (S,c,T) (S,d,T),还有(a,b) (b,c) (c,d) (d,a)

那些并不连到S与T的边,表示从别的边补给流量.

比如(S,a,b,T)这道流,就是我在塞满了b的下界以后,还从点a搬运了一些流来对b进行补给,确保b的后继能够得到足够的流量.

值得注意的是,蒜捣(CLRS)在思考题26-6以"负权流"的形式给出了构图法.

如果一条(u,v)边带负权c(u,v),意思就是"这条边的最大流为-c(u,v)",根据对称性,意思就是"这条边对应的反向边的最小流为-c(u,v)"

这里是模板.

有源有汇上下界最大流.

ZOJ3229

没有加人和优化.

代码又臭又长囧

需要再花点时间研究怎么写比较舒服.....(嗯然后再考虑常数优化问题....)

#include <cstdio>
#include <fstream>
#include <iostream>

#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>

#include <queue>
#include <vector>

typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;

#define DBG printf("*")

using namespace std;


struct edge
{
	int in;
	int c; //over limit flow
	edge*nxt;
	edge*ptr;
}pool[1000050];
edge*et;
edge*eds[2050];
inline edge*addedge(int i,int j,int c)
{
	et->ptr=et+1;
	et->in=j; et->c=c; et->nxt=eds[i]; eds[i]=et++;
	et->ptr=et-1;
	et->in=i; et->c=0; et->nxt=eds[j]; eds[j]=et++;
	return et-1;
}
#define FOREACH_EDGE(i,j) for(edge*i=eds[j];i;i=i->nxt)

const int INF=(1<<30)-1;

int n;

int st,ed;
int dep[2050];
bool used[2050];
int DFS(int x,int mi)
{
	if(x==ed) return mi;
	used[x]=true;
	int res=0,c;
	FOREACH_EDGE(i,x)
	if(i->c>0 && dep[x]+1==dep[i->in] && !used[i->in] && ( c=DFS(i->in,min(mi,i->c)) ))
	{
		i->c-=c;
		i->ptr->c+=c;
		res+=c;
		mi-=c;
		if(mi<=0) break;
	}
	used[x]=false;
	if(res<=0) dep[x]=-1;
	return res;
}

int q[2050];
int qh,qt;
int DINIC(int s,int e)
{
	st=s,ed=e;
	
	int res=0;
	
	while(true)
	{
		for(int i=0;i<n;i++)
		dep[i]=-1;
		
		qh=qt=0;
		q[qt++]=st;
		dep[st]=0;
		
		while(qh!=qt)
		{
			int&cur=q[qh];
			FOREACH_EDGE(i,cur)
			if(i->c>0 && dep[i->in]==-1)
			{
				dep[i->in]=dep[cur]+1;
				q[qt++]=i->in;
			}
			qh++;
		}
		
		if(dep[ed]==-1) break;
		
		res+=DFS(st,INF);
	}
	
	return res;
}


int dtot,gtot;

//blocks define
#define TIME(i) (i)
#define GIRL(i) (dtot+i)
#define Source (dtot+gtot)
#define Sink (dtot+gtot+1)
#define SSource (dtot+gtot+2)
#define SSink (dtot+gtot+3)

edge*rd[400000];
edge*rt[400000];
int rtot;

inline void addedge_lim(int i,int j,int c,int d,int k) //c is the lower limit.
{
	rd[rtot]=addedge(SSource,j,c);
	addedge(i,SSink,c);
	rt[rtot]=addedge(i,j,d-c);
	if(k)rtot++;
}

int R[400000];

int main()
{
	while(scanf("%d%d",&dtot,>ot)>0)
	{
		//Init
		
		n=dtot+gtot+4;
		
		for(int i=0;i<n;i++) eds[i]=NULL;
		et=pool;
		
		
		//read graph
		rtot=0;
		
		for(int i=0;i<gtot;i++)
		{
			int c;
			scanf("%d",&c);
			addedge_lim(GIRL(i),Sink,c,INF,0);
		}
		
		addedge_lim(Sink,Source,0,INF,0);
		
		for(int i=0;i<dtot;i++)
		{
			int p,c;
			scanf("%d%d",&p,&c);
			addedge_lim(Source,TIME(i),0,c,0);
			for(int j=0;j<p;j++)
			{
				int t,c,d;
				scanf("%d%d%d",&t,&c,&d);
				addedge_lim(TIME(i),GIRL(t),c,d,1);
			}
		}
		
		//flow lower limit
		DINIC(SSource,SSink);
		
		int ok=1;
		FOREACH_EDGE(i,SSource)
		if(i->c>0) { ok=0; break; }
		
		if(!ok)
		{
			printf("-1\n\n");
			continue;
		}
		
		//record
		for(int i=0;i<rtot;i++)
		R[i]=rd[i]->c;
		
		
		//original max flow
		
		FOREACH_EDGE(i,SSource)
		{
			i->c=0;
			i->ptr->c=0;
		}
		
		FOREACH_EDGE(i,SSink)
		{
			i->c=0;
			i->ptr->c=0;
		}
		
		int maxflow=DINIC(Source,Sink);

		printf("%d\n",maxflow);
		
		for(int i=0;i<rtot;i++)
		printf("%d\n",R[i]+rt[i]->c);
		printf("\n");
	}
	
	return 0;
}