图论笔记：网络流问题

---

前言

---

一、最大流

最大流问题：Ford-Fullkerson方法

Edmonds-Karp算法（EK）：

由于适用规模小所以用邻接矩阵存图

１.找到一条增广路２.找到瓶颈正向路径减少ｆｌｏｗ，反向路径增加ｆｌｏｗ３.直到找不到增广路

#include<bits/stdc++.h>
using namespace std;
//Edmonds-Karp算法 最大流问题
//hdu1532
const int inf=1e9;
const int maxn=300;
int n,m,G[maxn][maxn],pre[maxn];
int bfs(int s,int t)
{
	int flow[maxn];
	memset(pre,-1,sizeof(pre));
	flow[s]=inf;pre[s]=0;
	queue<int> Q;
	Q.push(s);
	while(!Q.empty())
	{
		int u=Q.front();
		Q.pop();
		if(u==t) break;
		for(int i=1;i<=m;i++){
			if(i!=s&&G[u][i]>0&&pre[i]==-1){
				pre[i]=u;
				Q.push(i);
				flow[i]=min(flow[u],G[u][i]);//更新结点流量 
			}
		}
	}
	if(pre[t]==-1) return -1;//没有找到新的增广路 
	return flow[t];
}
int maxflow(int s,int t)
{
	int Maxflow=0;
	while(1)
	{
		int flow=bfs(s,t);
		//执行一次BFS找到一条路径返回路径的流量
		if(flow==-1) break;//没有找到新的增广路
		int cur=t;//
		while(cur!=s)//一直沿路径回溯到起点 
		{
			int father=pre[cur];//pre记录路径上前一个点 
			G[father][cur]-=flow;//更新残留网络，正向减 
			G[cur][father]+=flow;
			cur=father;
		} 
		Maxflow+=flow; 
	}
	return Maxflow;
}
int main()
{
	while(cin>>n>>m)
    {
    	memset(G,0,sizeof(G));
		for(int i=0;i<n;i++){
			int u,v,w;
			cin>>u>>v>>w;
			G[u][v]+=w;//可能有重边 
		}	
		cout<<maxflow(1,m)<<endl;
	}	
	return 0;
} 

EK算法效率不高，竞赛中一般用ISAP算法**

最大流建模：

一 ， 无向图转换为有向图 二，多个源点s和汇点t：添加超级源点和超级汇点，从s到每个源点都有一条边，从每个汇点都连一个边到t

最小割问题：

最小费用最大流：

从零流开始，每次增加一个最小费用路径，经过多次增广，直到无法再增加路径。

最大流问题和最短路径问题结合。

由于存在负边（不是负环）所以只能用Ford-Fulkerson方法+SPFA算法

下面这道题是poj2135 把每条边的流量设为1每条边只能用一次，在图中添加一个超级源点和超级汇点

无向图变成四个边：首先分成有向边(u,v),(v,u);

有向边(u,v)变成一个正向的费用为cost ,容量为capacity的边，以及一个反向的费用为-cost,容量为0的边。

#include<iostream>
#include<cstring>
#include<queue>
#include<algorithm>
#include<stdio.h>
using namespace std;
//poj2135最小费用最大流
const int inf=0x3f3f3f3f;
const int N=1010;
int dis[N],pre[N],preve[N];//dis[i]记录起点到i的最短距离
int n,m;
struct edge{
	int to,cost,capacity,rev;
	//表示下一个点，费用，容量，前驱结点 
	edge(int a,int b,int c,int d){
		to=a;cost=b;capacity=c;rev=d;
	}
}; //邻接表存图
vector<edge> e[N];//存第i个结点连接的所有边 
void addedge(int from,int to,int cost,int capacity){
	e[from].push_back(edge(to,cost,capacity,e[to].size()));
	e[to].push_back(edge(from,-cost,0,e[from].size()-1));//把一个有向边再分为两个 
}
bool spfa(int s,int t,int cnt)
{
	bool inq[N];
	memset(pre,-1,sizeof(pre));
	for(int i=1;i<=cnt;i++){
		dis[i]=inf;inq[i]=false;
	}
	dis[s]=0;
	queue<int> Q;
	Q.push(s);
	inq[s]=true;
	while(!Q.empty())
	{
		int u=Q.front();
		Q.pop();
		inq[u]=false;
		for(int i=0;i<e[u].size();i++)
			if(e[u][i].capacity>0){
				int v=e[u][i].to,cost=e[u][i].cost;
				if(dis[u]+cost<dis[v]){
					dis[v]=dis[u]+cost;
					pre[v]=u;//v的前驱结点是u 
					preve[v]=i;//u的第i个边连接v点
					if(!inq[v]){
						inq[v]=true;
						Q.push(v);
					} 
				}
			}
	}
	return dis[t]!=inf;
}
int mincost(int s,int t,int cnt)
{
	int cost=0;
	while(spfa(s,t,cnt))
	{
		int v=t,flow=inf;//每次增加的流量 
		while(pre[v]!=-1){//回溯整个路径计算路径的流 
			int u=pre[v],i=preve[v];
			//u是v的前驱结点，u的第i个边连接v
			flow=min(flow,e[u][i].capacity);
			//所有边的最小容量是这条路的流
			v=u; 
		}
		v=t;
		while(pre[v]!=-1)
		{
			int u=pre[v],i=preve[v];
			e[u][i].capacity-=flow;
			e[v][e[u][i].rev].capacity+=flow;
			v=u;
		}
		cost+=dis[t]*flow;//费用累加，如果程序需要输出最大流， 
	}
	return cost; 
}
int main()
{
	while(~scanf("%d%d",&n,&m))
	{
		for(int i=0;i<N;i++) e[i].clear();
		for(int i=1;i<=m;i++)
		{
			int u,v,w;
			scanf("%d%d%d",&u,&v,&w);
			addedge(u,v,w,1);
			addedge(v,u,w,1);
		}
		int s=n+1,t=n+2;
		addedge(s,1,0,2);
		addedge(n,t,0,2);
		printf("%d\n",mincost(s,t,n+2));
	}
	return 0;
}

最大流问题变式：

变式一：多源点多汇点

添加超级源点t和超级汇点s，从s向每个源点连一个容量为对应最大流出容量的边，从每个汇点向t连一条容量为对应最大容量的边。

变式二：无向图

当作有向图两个方向的边容量相同

变式三：顶点上也有容量限制的情况

**把每个顶点拆成两个，从入顶点到出顶点连一条顶点容量的边