网络流问题

最新推荐文章于 2024-04-20 18:03:27 发布

2016cxg

最新推荐文章于 2024-04-20 18:03:27 发布

阅读量270

点赞数

本文链接：https://blog.csdn.net/qq_33785671/article/details/52828170

版权

//最大流问题
//增广路算法EdmondsKarp算法，当残量网络中不存在增广路时此时的流是最大流
//增广路算法时已标号节点集合为最小割集合s
//增广可以保证最大流和最小费用流条件式初始条件必须满足最大流或者最小费用流
#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int maxn=10000;
int n,m,w;
struct Edge{
   int from,to,cap,flow;
};
vector<Edge> edge;
vector<int> G[maxn];
int v[maxn],p[maxn];

int EdmondsKarp(int s,int t){
   int flow=0;
   while(1){
       memset(v,0,sizeof(v));
       queue<int> que;
       que.push(s);
       v[s]=0x3f3f3f3f;
       while(!que.empty()){
           int x=que.front();que.pop();
           for(int i=0;i<G[x].size();i++){
               Edge& e=edge[G[x][i]];
               if(!v[e.to]&&e.cap>e.flow){
                   p[e.to]=G[x][i];
                   v[e.to]=min(v[x],e.cap-e.flow);
                   que.push(e.to);
               }
           }
           if(v[t])break;
       }
       if(!v[t])break;
       for(int u=t;u!=s;u=edge[p[u]].from){
           edge[p[u]].flow+=v[t];
           edge[p[u]^1].flow-=v[t];
       }
       flow+=v[t];
   }
   return flow;
}
int main(){
   cin>>n>>m;
   for(int i=0;i<m;i++){
       int a,b,c;
       cin>>a>>b>>c;
       edge.push_back(Edge{a,b,c,0});
       edge.push_back(Edge{b,a,0,0});
       G[a].push_back(edge.size()-2);
       G[b].push_back(edge.size()-1);
   }

   int s=EdmondsKarp(0,5);
   cout<<s<<endl;
   return 0;

}

//最小费用最大流问题
//增广路算法MCMF
#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int maxn=10000;
int n,m,w;
struct Edge{
   int from,to,cap,flow,cost;
};
vector<Edge> edge;
vector<int> G[maxn];
int v[maxn],d[maxn],p[maxn],a[maxn];

int BellmanFord(int s,int t,int&flow,long long &cost){
   for(int i=0;i<n;i++)d[i]=0x3f3f3f3f;
   d[s]=0;
   memset(v,0,sizeof(v));
   v[s]=1;
   p[s]=0;
   a[s]=0x3f3f3f3f;
   queue<int> que;
   que.push(s);
   while(!que.empty()){
       int u=que.front();que.pop();
       v[u]=0;
       for(int i=0;i<G[u].size();i++){
           Edge&e=edge[G[u][i]];
           if(e.cap>e.flow&&d[e.to]>d[u]+e.cost){
               d[e.to]=d[u]+e.cost;
               p[e.to]=G[u][i];
               a[e.to]=min(a[u],e.cap-e.flow);
               if(!v[e.to]){
                   que.push(e.to);
                   v[e.to]=1;
               }
           }
       }
   }
   if(d[t]==0x3f3f3f3f)return 0;
   flow+=a[t];
   cost+=(long long)d[t]*(long long)a[t];
   for(int u=t;u!=s;u=edge[p[u]].from){
       edge[p[u]].flow+=a[t];
       edge[p[u]^1].flow-=a[t];
   }
   return 1;
}
int MCMF(int s,int t,long long& cost){
   int flow=0;cost=0;
   while(BellmanFord(s,t,flow,cost));
   return flow;
}
int main(){
   cin>>n>>m;
   for(int i=0;i<m;i++){
       int b,c,d,e;
       cin>>b>>c>>d>>e;
       edge.push_back(Edge{b,c,d,0,e});
       edge.push_back(Edge{c,b,0,0,e});
       G[b].push_back(edge.size()-2);
       G[c].push_back(edge.size()-1);
   }
   int flow;long long cost;
   flow=MCMF(0,2,cost);
   cout<<flow<<" "<<cost<<endl;
   return 0;
}