最大流
问题导入:我们想象一下自来水厂到你家的水管网是一个复杂的有向图,每一节水管都有一个最大承载流量。自来水厂不放水,你家就断水了。但是就算自来水厂拼命的往管网里面注水,你家收到的水流量也是上限(毕竟每根水管承载量有限)。你想知道你能够拿到多少水,这就是一种网络流问题。
简单来说就是水流从一个源点s通过很多路径,经过很多点,到达汇点t,问你最多能有多少水能够到达t点。
从s到t经过若干个点,若干条边,每一条边的水流都不能超过边权值(可以小于等于但不能大于),所以该图的最大流就是10+22+45=77
或者假设s城有inf个人想去t城,但是从s到t要经过一些城市才能到达,(以上图为例)其中s到3城的火车票还剩10张,3到t的火车票还剩15张,其他路以此类推,问最终最多能有多少人能到达t城?
EK算法
1.增广路:
增广路是指从s到t的一条路,流过这条路,使得当前的流(可以到达t的人)可以增加。
那么求最大流问题可以转换为不断求解增广路的问题,并且,显然当图中不存在增广路时就达到了最大流。
2.残余网络:
在一个网络流图上,找到一条源到汇的路径(这样会找到一个最小流量)后,对路径上所有的边,其容量都减去此次找的流量,对路径上所有的边,都添加一条反向边(这可以理解为反悔机制),其容量加上此次找到的流量,这样得到的新图,就称为原图的“残余网络
其实很简单,直接从s到t广搜即可,从s开始不断向外广搜,通过权值大于0的边(因为后面会减边权值,所以可能存在边权为0的边),直到找到t为止,然后找到该路径上边权最小的边,记为min,然后最大流加min,要把每一条经过的边的边权减去min,每条经过的边的反向边(反向边的反向边是正向边,负负得正)加上min 。
直到在新图(残余网络)找不到一条增广路(从s到t的一条路径)为止。
为什么残留网络中要有反向边?
如果你第一次的增广路是:s->3->5->t流量显然是10,第二次的增广路是s->4->5->t流量显然是35(因为5->t的流量有10点被3号点来的人占领了)。
而这种方案显然不如:s->4->5->t流量为45,s->3->t流量为10。
程序不知道如何走最优,所以添加一条反向边,相当于反悔机制。
走了s->3->5->t,那么残留
网络会变成:
再找一次增广路,比如说我们走s->4->5->t。
再找一次增广路,这次找s->4->5->3->t 。
这就好像是45个人沿着s->4->5->t的路线想去t城,到了5城却发现有10个来自3城的人先定了5->t的票!他们十分焦急,总不能让他们在5城等吧。怎么办呢?他们通过反向边上的标记发现了那10个人是来自3城的,利用标记,他们发现那10个人可以直接从3城到t城,于是他们告诉还在3城时的那10个人可以直接走3->t这条路,然后他们就可以买到空出来的5->t的10张票了。
EK模板
相当于每次bfs找一次增广路,并每次找到后,更新残余网络,直到找不到增广路
#include<bits/stdc++.h>
using namespace std;
const int maxn=1000;
const int INF=0x3f3f3f3f;
int Map[maxn][maxn];
int pre[maxn];
int s,e,n,flow;
int bfs(){
flow=INF; //flow记录这一条增广路的最小的流量
memset(pre,-1,sizeof(pre));
queue<int> q;
pre[s]=0;
q.push(s);
while(!q.empty()){
int u=q.front();
q.pop();
if(u==e) break;
for(int i=0;i<=n;i++){
if(i!=s&&pre[i]==-1&&Map[u][i]){
flow=min(flow,Map[u][i]);
q.push(i);
pre[i]=u;
}
}
}
if(pre[e]==-1) return -1; //找不到增广路
else
return flow;
}
int EK(){
int res=0;
int sum=0;
while(res=bfs()!=-1){
sum+=res;
int k=e;
while(k!=s){ //更新残余网络
int f=pre[k];
Map[k][f]+=res;
Map[f][k]-=res;
k=f;
}
}
return sum;
}
最大流的应用
1.单源单汇。
2.多源多汇:源有多个,汇也有多个,流可以从任意一个源流出,最终也可以流向任意一个汇点,总流量等于所有源流出的总流量,也等于流进所有汇点的总流量。
解法:加入一个超级源点s’和一个超级汇点t’,然后从s’向每个源引一条有向弧,容量为无穷大,每个汇点向超级汇点t’引一条弧容量为无穷大,接着求出超级源点到超级汇点的最大流即是答案。
3.结点容量问题:每个结点都有一个允许通过的最大流量,称为结点容量。
解法:把每个原始节点u分为两个结点u1和u2,中间连一条有向弧容量等于结点u的容量,原先到达结点u的弧改成到达u1,原先从结点u出发的弧改为从结点u2出发。
问题 A: 红红喂牛
时间限制: 1 Sec 内存限制: 128 MB
题目描述
红红为他的N(1 ≤ N ≤ 100)头牛准备了F(1 ≤ F ≤ 100)种食物和D(1 ≤ D ≤ 100)种饮料。每头牛都有各自喜欢的食物和饮料,而每种食物或饮料只能分配给一头牛。最多能有多少头牛同时得到自己喜欢的食物和饮料?
输入
第一行输入三个整数N,F, D。
接下来n行,每行先输入两个整数 Fi 和 Di,分别表示编号为 i 的牛喜欢的食物和饮料的数量,接下来的Fi个整数表示第i头牛喜欢的食物的编号,最后Di个整数表示第i头牛喜欢的饮料的编号。
输出
输出同时得到喜欢的食物和饮料的牛的数量的最大值。
样例输入
4 3 3
2 2 1 2 3 1
2 2 2 3 1 2
2 2 1 3 1 2
2 1 1 3 3
样例输出
3
分析:
这是一个多源多汇加上结点容量的题
牛拆成两个节点,一个饮料的一个饭的
三角形表示:牛本来的编号
需对整个图重新编号
牛拆成两个重新编号:2 * i-1~2 * i(i:牛本来的编号) 牛的标号范围:1~ 2 * n
饮料的标号范围:2 * n+f+1~2 * n+f+n
食物的标号范围:2 * n+1~2 * n+f
#include<bits/stdc++.h>
using namespace std;
const int maxn=1000;
const int INF=0x3f3f3f3f;
int Map[maxn][maxn];
int pre[maxn];
int s,e,n,flow;
int bfs(){
flow=INF;
memset(pre,-1,sizeof(pre));
queue<int> q;
pre[s]=0;
q.push(s);
while(!q.empty()){
int u=q.front();
q.pop();
if(u==e) break;
for(int i=0;i<=n;i++){
if(i!=s&&pre[i]==-1&&Map[u][i]){
flow=min(flow,Map[u][i]);
q.push(i);
pre[i]=u;
}
}
}
if(pre[e]==-1) return -1;
else
return flow;
}
int EK(){
int res=0;
int sum=0;
while(res=bfs()!=-1){
sum+=res;
int k=e;
while(k!=s){
int f=pre[k];
Map[k][f]+=res;
Map[f][k]-=res;
k=f;
}
}
return sum;
}
int main(){
int N,F,D;
cin>>N>>F>>D;
n=F+D+2*N+1;
s=0,e=n;
for(int i=1;i<=F;i++){
Map[0][i]=1;
}
for(int i=F+2*N+1;i<=F+2*N+D;i++){
Map[i][n]=1;
}
for(int i=1;i<=N;i++){
Map[F+2*i-1][F+2*i]=1;
}
int k1,k2,u;
for(int i=1;i<=N;i++){
cin>>k1>>k2;
for(int j=1;j<=k1;j++){
cin>>u;
Map[u][F+2*i-1]=1;
}
for(int j=1;j<=k2;j++){
cin>>u;
Map[F+2*i][F+2*N+u]=1;
}
}
cout<<EK()<<endl;
}
最小割
图的割:对于某个顶点集合S,从S出发指向S外部的那些边的集合,即为割V\S。这些边的容量之和被称为割的容量。
s-t割:在一个网络中,如果s∈S,且t∈V\S,那么此时的割称为s-t割。
最小割问题:对于给定网络,为了保证从源点s到汇点t的路径不存在,在图中需要删除的边的总容量值最小。
最大流最小割定理:在任何网络中,最大流的值等于最小割的容量
最大权闭合子图:
给定带权图G(权值可正可负),求一个权和最大的点集,使得起点在该点集中的任意弧,终点也在该点集中。
解法:新增附加源s和附加汇t,从s向所有正权点引一条弧,权值为该点的容量;从所有负权边向汇点引一条弧,容量为权值的相反数,将图中原有的边权值变为INF。求出最小割之后S – {s}就是最大闭合子图
最小费用最大流
以下图为例:图中没打()的为边权(最大流量),打()的为单位流量的价格。我们再用刚刚买火车票的样例解释:假设s城有inf个(穷)人想去t城,但是从s到t要经过一些城市才能到达,其中s到3城的火车票还剩10张票价为6元/人,3到t的火车票还剩15张票价为7元/人,其他路以此类推,问最终最多能有多少人能到达t城?
(由于是穷人)他们希望能在最多人到达t城的同时花最少的钱,问最少的钱是多少
费用流最大流就是在求出最大流的前提下保证是最小花费,第一想法是我们在寻找增广路的时候不能使用bfs,而是换做最短路算法spfa即可解决问题
反向边的花费为正向边的相反数。
其实很好理解,如果那几个人不走这条路,那么这条路的钱就不用花了,但是因为刚才(前面走过的增广路)走过时花了钱,这次走反向边要退钱。
然后就是计算最大流和对应的最小费用了
最小费用最大流模板
#include<bits/stdc++.h>
using namespace std;
const int maxn=1000;
const int INF=0x3f3f3f3f;
struct edge{ //链式前向星
int to,cap,w,next; //to :终点 cap容量 w 权值
}edge[maxn*maxn];
int head[maxn];
int cnt;
int n,m;
int vis[maxn],dis[maxn],pre[maxn];
void init(){
memset(head,-1,sizeof(head));
cnt=0;
}
void addedge(int u,int v,int c,int w){
//正向边
edge[cnt].to=v;
edge[cnt].cap=c;
edge[cnt].w=w;
edge[cnt].next=head[u];
head[u]=cnt++;
//反向边
edge[cnt].to=u;
edge[cnt].cap=0;
edge[cnt].w=-w;
edge[cnt].next=head[v];
head[v]=cnt++;
}
bool spfa(int s,int e){
memset(vis,0,sizeof(vis));
memset(dis,INF,sizeof(dis));
memset(pre,-1,sizeof(pre));
queue<int> q;
q.push(s);
vis[s]=1;
dis[s]=0;
while(!q.empty()){
int u=q.front();
q.pop();
vis[u]=0;
for(int i=head[u];~i;i=edge[i].next){
int v=edge[i].to;
int cap=edge[i].cap;
if(dis[v]>dis[u]+edge[i].w&&cap>0){ //一定要加上cap>0
dis[v]=dis[u]+edge[i].w;
pre[v]=i; //记录父亲边
if(!vis[v]){
vis[v]=1;
q.push(v);
}
}
}
}
if(dis[e]==INF)
return false;
else
return true;
}
int MincostMaxflow(int s,int e,int &cost){
int maxflow=0;
while(spfa(s,e)){
int minflow=INF;
for(int i=pre[e];i!=-1;i=pre[edge[i^1].to]) //要求正向边的起点,就求反向边的终点 ^1 偶数+1,奇数-1
minflow=min(minflow,edge[i].cap);
for(int i=pre[e];i!=-1;i=pre[edge[i^1].to]){
edge[i].cap-=minflow;
edge[i^1].cap+=minflow;
cost+=minflow*edge[i].w;
}
maxflow+=minflow;
}
return maxflow;
}
问题 B: 红红分房
题目描述
土豪红红突然兴致大发准备免费送大家一套房子,现在他有一张N行M列的地图,地图中m表示一个人,H表示一幢房子,每个房子只能被一个人选。红红决定为了方便起见让所有人到自己房子的距离和最小(人到房子的距离为人到房子所走的步数),请问这个距离和是多少?
输入
输入包含多组测试样例。n和m都为零时表示程序结束。
每组测试样例输入第一行包含两个整数n和m,表示这个地图的行数和列数。
接下来n行m列表示红红的地图。
输出
输出题目要求的最小距离和。
样例输入
2 2
.m
H.
5 5
HH…m
…
…
…
mm…H
7 8
…H…
…H…
…H…
mmmHmmmm
…H…
…H…
…H…
0 0
样例输出
2
10
28
最小费用最大流模板题
并且是多源多汇
在每个人和每个房子之间建边,权值为他们之间的距离fasbs(house.x-people.x)+fabs(house.y-people.y),容量为1
#include<bits/stdc++.h>
using namespace std;
const int maxn=1000;
const int INF=0x3f3f3f3f;
struct edge{
int to,cap,w,next;
}edge[maxn*maxn];
int head[maxn];
int cnt;
char Map[maxn][maxn];
int n,m;
int vis[maxn],dis[maxn],pre[maxn];
struct info{
int num,x,y;
};
void init(){
memset(head,-1,sizeof(head));
cnt=0;
}
void addedge(int u,int v,int c,int w){
//正向边
edge[cnt].to=v;
edge[cnt].cap=c;
edge[cnt].w=w;
edge[cnt].next=head[u];
head[u]=cnt++;
//反向边
edge[cnt].to=u;
edge[cnt].cap=0;
edge[cnt].w=-w;
edge[cnt].next=head[v];
head[v]=cnt++;
}
bool spfa(int s,int e){
memset(vis,0,sizeof(vis));
memset(dis,INF,sizeof(dis));
memset(pre,-1,sizeof(pre));
queue<int> q;
q.push(s);
vis[s]=1;
dis[s]=0;
while(!q.empty()){
int u=q.front();
q.pop();
vis[u]=0;
for(int i=head[u];~i;i=edge[i].next){
int v=edge[i].to;
int cap=edge[i].cap;
if(dis[v]>dis[u]+edge[i].w&&cap>0){ //一定要加上cap>0
dis[v]=dis[u]+edge[i].w;
pre[v]=i; //记录父亲边
if(!vis[v]){
vis[v]=1;
q.push(v);
}
}
}
}
if(dis[e]==INF)
return false;
else
return true;
}
int MincostMaxflow(int s,int e,int &cost){
int maxflow=0;
while(spfa(s,e)){
int minflow=INF;
for(int i=pre[e];i!=-1;i=pre[edge[i^1].to]) //要求正向边的起点,就求反向边的终点 ^1 偶数+1,奇数-1
minflow=min(minflow,edge[i].cap);
for(int i=pre[e];i!=-1;i=pre[edge[i^1].to]){
edge[i].cap-=minflow;
edge[i^1].cap+=minflow;
cost+=minflow*edge[i].w;
}
maxflow+=minflow;
}
return maxflow;
}
int main(){
while((cin>>n>>m)&&(n||m)){
init();
int start=0,end=n*m+1;
for(int i=0;i<n;i++){
scanf("%s",Map[i]);
}
vector<info> people,house;
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(Map[i][j]=='.') continue;
if(Map[i][j]=='H'){
int num=i*m+j+1;
people.push_back((info){num,i,j});
}
if(Map[i][j]=='m'){
int num=i*m+j+1;
house.push_back((info){num,i,j});
}
}
}
for(int i=0;i<people.size();i++){
info ipeople=people[i];
addedge(start,ipeople.num,1,0);
}
for(int i=0;i<house.size();i++){
info ihouse=house[i];
addedge(ihouse.num,end,1,0);
}
for(int i=0;i<people.size();i++){
for(int j=0;j<house.size();j++){
info ipeople=people[i];
info ihouse=house[j];
int dis=fabs(ipeople.x-ihouse.x)+fabs(ipeople.y-ihouse.y);
addedge(ipeople.num,ihouse.num,1,dis);
}
}
int cost=0;
MincostMaxflow(start,end,cost);
cout<<cost<<endl;
}
return 0;
}