【BZOJ3597】方伯伯运椰子（分数规划，网络流）

【BZOJ3597】方伯伯运椰子（分数规划，网络流）

题解

给定了一个满流的费用流模型

如果要修改一条边，那么就必须满足流量平衡

也就是会修改一条某两点之间的路径上的所有边

同时还有另外一条路径会进行相反的修改

现在要求最大化\(\frac{X-Y}{K}\)

二分答案\(mid\)

式子变为\(X-Y-K·mid\geq 0\)

换而言之，相当于给每次修改操作额外付出一个代价\(mid\)

要使得费用+修改代价最小

对于扩容我们很好处理

对于每条边再额外连一条边

容量为\(inf\)（可以无限扩容），费用为扩容的费用，同时，每次流过还会产生一个费用

所以扩容的费用是\(b+d\)

但是压缩呢？

对于每次压缩，相当于是退流了

所以，我们给反边的费用额外增加一个压缩的费用

所以这里的费用是\(a-d\)

但是，似乎还是不会做？

我们虽然这样处理了，但是不知道怎么计算结果。

在看了天哥的博客后，我发现了这题真的很妙啊

我们先假设所有的边都被你压缩成零了，产生了一定的费用，这个可以直接算贡献。

接下来我们有两种边

一种是反压缩，我们把压缩的容量给还原，容量是边的容量，费用是\(d-a\)。

另外一种就是扩容，也就是额外新增容量，容量为\(inf\)，费用\(b+d\)

再把分数规划给套上去，把每个费用都加上一个\(mid\)（反压缩是减）

这样给源点流量为原图中的流量，做一次费用流就好啦。

然后我们再来想一想我们的分数规划变成了求什么。

本来是让\(X-Y-K·mid\geq 0\)

也就是\(Y+K·mid-X\leq 0\)

因为提前压缩的时候我们已经把所有的流量贡献的费用给减掉了

也就是我们已经减过\(X\)了

所以就是最后费用流的结果+压缩所有边的费用之和要小于\(0\)

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define RG register
#define MAX 5555
#define inf 1000000000
inline int read()
{
    RG int x=0,t=1;RG char ch=getchar();
    while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
    if(ch=='-')t=-1,ch=getchar();
    while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
    return x*t;
}
int n,m,S,T;
int U[MAX],V[MAX],A[MAX],B[MAX],C[MAX],D[MAX];
struct Line{int v,next,w;double fy;}e[50000];
int h[MAX],cnt=2;
inline void Add(int u,int v,int w,double fy)
{
	e[cnt]=(Line){v,h[u],w,fy};h[u]=cnt++;
	e[cnt]=(Line){u,h[v],0,-fy};h[v]=cnt++;
}
double sum,Sum;
void Build(double mid)
{
	memset(h,0,sizeof(h));cnt=2;sum=0;
	for(int i=1;i<=m;++i)
	{
		if(U[i]!=S)Add(U[i],V[i],inf,B[i]+D[i]+mid);
		Add(U[i],V[i],C[i],-(A[i]-D[i]+mid));
		sum+=C[i]*(A[i]-D[i]+mid);
	}
}
int pe[MAX],pv[MAX];
double dis[MAX];
bool vis[MAX];
bool SPFA()
{
	for(int i=1;i<=T;++i)dis[i]=1e18;
	dis[S]=0;vis[S]=true;
	queue<int> Q;Q.push(S);
	while(!Q.empty())
	{
		int u=Q.front();Q.pop();
		for(int i=h[u];i;i=e[i].next)
		{
			int v=e[i].v;if(!e[i].w)continue;
			if(dis[v]>dis[u]+e[i].fy)
			{
				dis[v]=dis[u]+e[i].fy;
				pv[v]=u;pe[v]=i;
				if(!vis[v])vis[v]=true,Q.push(v);
			}
		}
		vis[u]=false;
	}
	if(dis[T]>=1e18)return false;
	int flow=inf;
	for(int i=T;i!=S;i=pv[i])flow=min(flow,e[pe[i]].w);
	for(int i=T;i!=S;i=pv[i])e[pe[i]].w-=flow,e[pe[i]^1].w+=flow;
	sum+=flow*dis[T];
	return true;
}
bool check(double mid)
{
	Build(mid);
	while(SPFA());
	return sum<0;
}
int main()
{
	n=read();m=read();S=n+1;T=n+2;
	for(int i=1;i<=m;++i)
		U[i]=read(),V[i]=read(),A[i]=read(),B[i]=read(),C[i]=read(),D[i]=read();
	double l=0,r=5e4;
	while(r-l>1e-3)
	{
		double mid=(l+r)/2;
		if(check(mid))l=mid;
		else r=mid;
	}
	printf("%.2lf\n",l);
	return 0;
}

---

当然，还有另外一种方法

费用流上的消圈定理：

如果残余网络上还有负环，证明当前不是最优的费用流

因此，构建出残余网络之后直接检查有无负环即可

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define RG register
#define MAX 5555
inline int read()
{
    RG int x=0,t=1;RG char ch=getchar();
    while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
    if(ch=='-')t=-1,ch=getchar();
    while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
    return x*t;
}
struct Line{int v,next;int w;}e[MAX<<2];
int h[MAX],cnt=1;
inline void Add(int u,int v,int w){e[cnt]=(Line){v,h[u],w};h[u]=cnt++;}
int n,m,U,V,A,B,C,D;
double dis[MAX];
bool vis[MAX];
bool SPFA(int u,double mid)
{
	vis[u]=true;
	for(int i=h[u];i;i=e[i].next)
	{
		int v=e[i].v;
		if(dis[v]>dis[u]+e[i].w+mid)
		{
			dis[v]=dis[u]+e[i].w+mid;
			if(vis[v]||SPFA(v,mid))return true;
		}
	}
	vis[u]=false;
	return false;
}
bool check(double mid)
{
	for(int i=1;i<=n+2;++i)dis[i]=0,vis[i]=false;
	for(int i=1;i<=n+2;++i)
		if(SPFA(i,mid))return true;
	return false;
}
int main()
{
	n=read();m=read();
	for(int i=1;i<=m;++i)
	{
		U=read(),V=read(),A=read(),B=read(),C=read(),D=read();
		Add(U,V,B+D);if(C)Add(V,U,A-D);
	}
	double l=0,r=5e4;
	while(r-l>1e-3)
	{
		double mid=(l+r)/2;
		if(check(mid))l=mid;
		else r=mid;
	}
	printf("%.2lf\n",l);
	return 0;
}