【Luogu P3376】网络最大流

Luogu P3376

最大流是网络流模型的一个基础问题。

网络流模型就是一种特殊的有向图。

概念：

• 源点：提供流的节点，类比成为一个无限放水的水厂
• 汇点：接受流的节点，类比成为一个无限收水的小区
• 弧：类比为水管
• 弧的容量：类比为水管的容量；用函数\(c(x,y)\)表示弧\((x,y)\)的容量
• 弧的流量：类比为当前在水管中水的量；用函数\(f(x,y)\)表示弧\((x,y)\)的流量
• 弧的残量：即容量-流量
• 容量网络：对于一个网络流模型，每一条弧都给出了容量，则构成一个容量网络。
• 流量网络：对于一个网络流模型，每一条弧都给出了流量，则构成一个流量网络。
• 残量网络：对于一个网络流模型，每一条弧都给出了残量，则构成一个残量网络。最初的残量网络就是容量网络。

对于网络流模型\(G=(V,E)\)（\(V\)为点集，\(E\)为边集）有如下性质：

• 流量守恒：除了源点与汇点之外，流入任何节点的流一定等于流出该节点的流
• 容量限制：\(\forall (x,y) \in E，有0<=f(x,y)<=c(x,y)\)
• 斜对称性：\(\forall (x,y) \in E，有f(x,y)=-f(y,x).\)类似于函数奇偶性中的奇函数，或者是矢量的方向。

最大流问题，用通俗的方式解释就是从源点S到汇点T输送流量，询问最多有多少流量能输送到汇点。

对于这样的问题，我们引入一些新概念：

• 增广路：一条从源点到汇点的路径\(R\)，满足\(\forall (x,y) \in R, c(x,y)-f(x,y)>0.\)即残量为正数
• 最大流最小割定理：网络流模型达到最大流，当且仅当残量网络中没有任何增广路（并不完整，但是足够了）

\(Ford-Fulkerson\)方法：每一次寻找一条增广路径。根据木桶原理，该增广路的最大流量\(f_{max}<=min(c(x,y)-f(x,y))\)。据此从源点发送流量至汇点并修改路径上所有弧的残量，直到无法找到增广路为止。

\(Edmons-Karp\)算法：基于\(Ford-Fulkerson\)方法的一种算法，核心就是利用\(BFS\)搜索源点到汇点的最短增广路，根据\(Ford-Fulkerson\)方法修改残量网络。复杂度最坏是\(O(nm^2)\)

所以其实我们在求最大流相关问题时，其实只利用到了残量网络，流量和容量一般并不需要记录。

关键点：有时候在求最大流时我们可能需要缩减一条边的流量，所以我们引入了反向边。当我们选用了一条反向边时，相当于缩减正向边的流量。很容易发现反向边的残量等于正向边的流量（最多恰好抵消正向流量）。

这样就能保证算法的正确性。

#include<cstdio>
#include<algorithm>
#include<queue>
#include<cstring>
using namespace std;
struct data
{
	int to,next,val;
}e[2*100005];
int cnt,head[10005],prep[10005],pree[10005],flow[10005],ans;
queue<int> que;
int n,m,s,t,u,v,w;
void add(int u,int v,int w)
{
	e[++cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
	e[cnt].val=w;
}
int bfs(int s,int t)
{
	while (!que.empty()) que.pop();
	flow[s]=0x3f3f3f3f;//flow记录的是在增广路上经过该点的流量
	que.push(s);
	for (int i=1;i<=n;i++)
	{
		prep[i]=-1;//用于记录前驱节点
		pree[i]=0;//用于记录前驱边的编号
	}
	prep[s]=0;
	while (!que.empty())
	{
		int now=que.front();
		que.pop();
		if (now==t) break;
		for (int i=head[now];i;i=e[i].next)
		{
			if (e[i].val>0&&prep[e[i].to]==-1)
			{
				que.push(e[i].to);
				flow[e[i].to]=min(flow[now],e[i].val);
				pree[e[i].to]=i;
				prep[e[i].to]=now;
			}
		}
	}
	if (prep[t]!=-1) return flow[t];
	else return -1;
}
void EK(int s,int t)
{
	int delta=bfs(s,t);//寻找最短增广路的最大流量
	while (delta!=-1)
	{
		ans+=delta;
		for (int j=t;j;j=prep[j])
		{
			e[pree[j]].val-=delta;
			e[pree[j]^1].val+=delta;
			//链式前向星存边从编号2开始存储可以通过异或1快速取得反向边的编号。
		}
		delta=bfs(s,t);
	}
}
int main()
{
	scanf("%d%d%d%d",&n,&m,&s,&t);
	cnt=1;
	for (int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&u,&v,&w);
		add(v,u,0);
		add(u,v,w);
		//加入正反边
	}
	EK(s,t);
	printf("%d",ans);
	return 0;
}

Luogu P3381

假设现在对每一条弧加入一个费用，表示该弧单位流量需要的费用，要求最小费用最大流。

那么这就是费用流问题。

事实上并不难，对EK算法稍作修改，将EK中BFS寻找最短增广路改成SPFA寻找最小费用的增广路即可

#include<cstdio>
#include<queue>
using namespace std;
const int maxn=5005,maxm=50005,inf=0x3f3f3f3f;
struct data
{
	int to,next,val,pri;
}e[2*maxm];
int cnt,tot,ans,head[maxn],n,m,s,t,u,v,w,f,cost[maxn],prep[maxn],pree[maxn],flow[maxn];
void add(int u,int v,int w,int f)
{
	e[++cnt].to=v;
	e[cnt].next=head[u];
	e[cnt].val=w;
	e[cnt].pri=f;
	head[u]=cnt;
}
queue<int> que;
int vis[maxn];
int SPFA(int s,int t)
{
	for (int i=1;i<=n;i++)
	{
		cost[i]=inf;
		prep[i]=-1;
		pree[i]=0;
		flow[i]=inf;
                //初始化容易漏
	}
	cost[s]=0;
	que.push(s);
	vis[s]=true;
	prep[s]=0;pree[s]=0;flow[s]=inf;
	while (!que.empty())
	{
		int now=que.front();
		que.pop();
		vis[now]=false;
		for (int i=head[now];i;i=e[i].next)
		{
			if (e[i].val>0&&cost[e[i].to]>cost[now]+e[i].pri)
			{
				cost[e[i].to]=cost[now]+e[i].pri;
				flow[e[i].to]=min(flow[now],e[i].val);
				prep[e[i].to]=now;
				pree[e[i].to]=i;
				if (!vis[e[i].to])
				{
					vis[e[i].to]=true;
					que.push(e[i].to);
				}
			}
		}
	}
	if (prep[t]!=-1) return flow[t];
	else return -1;
}
void EK(int s,int t)
{
	int delta=SPFA(s,t);
	while (delta!=-1)
	{
		ans+=delta;tot+=delta*cost[t];
		for (int j=t;j;j=prep[j])
		{
			e[pree[j]].val-=delta;
			e[pree[j]^1].val+=delta;
		}
		delta=SPFA(s,t);
	}
}
int main()
{
	scanf("%d%d%d%d",&n,&m,&s,&t);
	cnt=1;
	for (int i=1;i<=m;i++)
	{
		scanf("%d%d%d%d",&u,&v,&w,&f);
		add(u,v,w,f);
		add(v,u,0,-f);//反向边的费用取相反数
	}
	EK(s,t);
	printf("%d %d",ans,tot);
	return 0;
}