看文章各种不明真相...
请教了一下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;
}