最大流+最小费用最大流

最新推荐文章于 2023-09-20 09:48:46 发布

ReverieZH

最新推荐文章于 2023-09-20 09:48:46 发布

阅读量1.2k

点赞数

分类专栏： ACM 文章标签： acm 最大流最小费用最大流

本文链接：https://blog.csdn.net/weixin_44035017/article/details/99687662

版权

ACM 专栏收录该内容

46 篇文章 3 订阅

订阅专栏

最大流

问题导入：我们想象一下自来水厂到你家的水管网是一个复杂的有向图，每一节水管都有一个最大承载流量。自来水厂不放水，你家就断水了。但是就算自来水厂拼命的往管网里面注水，你家收到的水流量也是上限（毕竟每根水管承载量有限）。你想知道你能够拿到多少水，这就是一种网络流问题。
简单来说就是水流从一个源点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;
}

ReverieZH

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
最大流+最小费用最大流

最大流问题导入：我们想象一下自来水厂到你家的水管网是一个复杂的有向图，每一节水管都有一个最大承载流量。自来水厂不放水，你家就断水了。但是就算自来水厂拼命的往管网里面注水，你家收到的水流量也是上限（毕竟每根水管承载量有限）。你想知道你能够拿到多少水，这就是一种网络流问题。简单来说就是水流从一个源点s通过很多路径，经过很多点，到达汇点t，问你最多能有多少水能够到达t点。从s到t经过若干个点，若...
复制链接

扫一扫