关于模拟网络流

目录

• 参考文献
• 模拟最大流
  • 题意
  • 思路
  • 我的思路
  • 小结
• 模拟费用流
  • 普通模版
    • 题意
    • 思路
    • 树上模拟
  • 时间复杂度的证明
    • 非树证明
    • 树上
  • 小结

参考文献

https://blog.csdn.net/litble/article/details/88410435
https://www.mina.moe/archives/11762

模拟最大流

题意

其实是CF 724 E

这其实是师兄改编了题目QMQ，真实范围应该是(n<=10000)

思路

这道题目很明显可以用网络流来做：

但是范围直接T了。

然后我们可以用贪心

然后我们发现这个图貌似有神奇的性质，利用最大流=最小割，我们可以枚举最小割。

最小割的性质就是每个点要么位于(st)集合或者(ed)集合，所以我们就可以先枚举出一种情况：

我们发现这个中间的边也要处理，所以对于(st,ed)我们还要处理一下，但是我们要如何处理最小割呢？

我们设(f[i][j])表示的是到了第(i)个点，有(j)个归到(st)集合。（归到(st)集合就是割掉(ed)）

那么不计(C)的影响的话，不难列出：
(f[i][j]=min(f[i-1][j-1]+b[i],f[i-1][j]+a[i]))。

但是如何处理(C)呢，不难发现对于(i,j(i<j))如果(i)选了(ed)，(j)选了(st)，那么就会有个(C)。

这个该归到(st)还是(ed)呢，很明显为了DP没有后效性，我们就归到(ed)吧。

那么DP转移方程变成了：(f[i][j]=min(f[i-1][j-1]+b[i],f[i-1][j]+a[i]+j*C))。

就可以转移了，时间复杂度(O(n^2))，当然，这个又叫模拟网络流。

#include<cstdio>
#include<cstring>
#define  N  2100
using  namespace  std;
typedef  long  long  LL;
inline  LL  mymin(LL  x,LL  y){return  x<y?x:y;}
LL  f[2][N],m;
int  a[N],b[N],n;
int  main()
{
//	freopen("c.in","r",stdin);
//	freopen("c.out","w",stdout);
	scanf("%d%lld",&n,&m);
	for(int  i=1;i<=n;i++)scanf("%d",&a[i]);
	for(int  i=1;i<=n;i++)scanf("%d",&b[i]);
	int  pre=0,now=1;
	for(int  i=1;i<=n;i++)
	{
		pre^=now^=pre^=now;
		f[now][0]=f[pre][0]+a[i];
		for(int  j=1;j<i;j++)f[now][j]=mymin(f[pre][j-1]+b[i],f[pre][j]+a[i]+j*m);
		f[now][i]=f[pre][i-1]+b[i];
	}
	LL  ans=(LL)9999999999999999;
	for(int  i=0;i<=n;i++)ans=mymin(ans,f[now][i]);
	printf("%lld
",ans);
	return  0;
}

我的思路

我是采用贪心，这道题目(n)才(2000)，还开(2s)，那么我们不难想到一种贪心思路，就是使得所有卖完粮食后剩余粮食大于(C)的位置的粮食尽量的平衡。

也就是尽可能的榨干这个(C)，使得后面每个位置都可以堆满(C)。

至于平衡的值，我们采用二分查找，那么时间复杂度(O(n^2log值域))。

而且还有优化，(1s)内过掉。

#include<cstdio>
#include<cstring>
#include<queue>
#define  N  3100
using  namespace  std;
typedef  long  long  LL;
template  <class  T>
inline  T  mymin(T  x,T  y){return  x<y?x:y;}
int  a[N],b[N];
priority_queue<int>q;//储存粮食信息，当然是大于C的才给放
int  sta[N],top;//表示可以移动的粮食 
int  list[N],tail;
int  n,m;
LL  zans;
bool  check(int  x,int  k/*原本的数字*/)
{
	for(int  i=1;i<=top;i++)
	{
		if(sta[i]<=x)return  false;
		k+=mymin(sta[i]-x,m);//可以给你多少的数字 
		if(k>=x)return  true;
	}
	return  false;
}
void  work(int  x,int  y)
{
	top=0;
	while(!q.empty())sta[++top]=q.top(),q.pop();
	int  k=x-y;//可能是负数
	if(top)//有大于C的粮食位置
	{
		int  l=k+1,r=mymin((LL)sta[1],(LL)k+(LL)top*(LL)m),mid,ans=k/*就是不变*/;//表示范围，而且能防止m过小时时间过大
		while(l<=r)
		{
			mid=(l+r)/2;
			if(check(mid,k)==true)ans=mid,l=mid+1;
			else  r=mid-1;
		}
		for(int  i=1;i<=top;i++)
		{
			if(k==ans)break;
			int  zjj=mymin(mymin(ans-k,m),sta[i]-ans);sta[i]-=zjj;k+=zjj;
		}
	}
	if(k<0)
	{
		while(k<0  &&  tail)k+=list[tail--];
	}
	zans+=mymin(y,k+y);
	if(k>0)
	{
		if(k<=m)list[++tail]=k;
		else  q.push(k);
	}
	for(int  i=1;i<=top;i++)
	{
		if(sta[i]<=m)list[++tail]=sta[i];
		else  q.push(sta[i]);
	}
}
int  main()
{
//	freopen("c.in","r",stdin);
//	freopen("c.out","w",stdout);
	scanf("%d%d",&n,&m);
	for(int  i=1;i<=n;i++)scanf("%d",&a[i]);
	for(int  i=1;i<=n;i++)scanf("%d",&b[i]);
	for(int  i=1;i<=n;i++)
	{
		work(a[i],b[i]);
	}
	printf("%lld
",zans);
	return  0;
}

小结

一般模拟最大流都是模拟最小割。

模拟费用流

普通模版

题意

题目链接

思路

我们很容易可以想出费用流的构图。

但是这里我们要用贪心加堆模拟费用流。

那么可以发现，这道题目表示的是(n)只兔子，有(m)个洞，洞有容量，允许左右走，要求每只兔子必须进洞（因为菜的数量和送菜员一样）。

(x)为坐标，(s)为洞的附加权值。

对于一只兔子(a)选了前面的一个洞(b)，那么产生的费用为(x_a-x_b+s_b)，而洞的最小值，可以从洞的小根堆直接取。

那么如果后面的一个洞(c)抢了(a)，那么就可以多出(s_c+x_c-x_a-(x_a-x_b+s_b)=s_c+x_c-2x_a+x_b-s_b)，那么我们只需要添加一个兔子，权值为(-2x_a+x_b-s_b)，然后我们对于每个洞，都可以取兔子的堆顶，如果贡献(<0)，那么就可以选了，而如果选了我们构造出来的兔子，就相当于退流，不选洞(b)。

当然是不可能有兔子抢(b)的，因为这样结果不会是最优的。

但是对于洞(b)选了兔子(a)，那么造成的价值应该是(v_a+s_b+x_b)（(v_a)为(a)在堆中的值），那么如果后面的兔子(c)要抢(b)的话，那么增加贡献就是(-v_a-2*x_b)，那么我们需要在洞堆添加这个数字。

你又会问了，那一个兔子的洞被抢了，而洞的兔子又被抢了，不就剩了一对兔子和洞了吗，但是如果你仔细的观察式子就会发现，其实这样子抢的话，这一对的价值是会算上的（其实就是把换的增值去掉了）。

而如果洞(b)选了兔子(a)，而(c)洞抢了(a)呢？那么很明显设一个兔子权值为(-s_b-x_b)就行了，而且这个贪心的正确性在于一个兔子一定进了一个洞，就也就是不管后面怎么抢选他的洞，他都可以回原来的洞。

不过其实如果兔子不一定要求进洞的话，不给他搞洞其实也是可以的，我们考虑为什么可能会错呢？就是我们担心洞找兔子后，添加的洞和兔子的后悔操作同时被触发，但是其实是不会的（而且如果兔子不是必须进洞，你也可以认为兔子进了自己脚下的洞，就是不选）。

因为后面的兔子和洞匹配怕不是更优QMQ。

但是讲了这么多兔子一定要进洞怎么搞，我们只要设无限远的地方有一些洞就行了。

同时多个洞就可以用(pair)记录有多少个洞。

而且因为兔子就(n)个，所以堆的个数就是(n)个，(O(nlogn))。

代码来自https://blog.csdn.net/litble/article/details/88410435。

#include<bits/stdc++.h>
using namespace std;
#define RI register int
int read() {
	int q=0;char ch=' ';
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
	return q;
}
typedef long long LL;
typedef pair<LL,LL> PR;
const LL inf=1e15;
const int N=100005;
int n,m;LL ans,sumc;
struct node{LL x,w,c;}t[N<<1];
bool cmp(node A,node B) {return A.x<B.x;}
priority_queue<PR,vector<PR>,greater<PR> > q1,q2;

void work() {
	q1.push((PR){inf,n});
	for(RI i=1;i<=n+m;++i) {
		if(t[i].w==-1) {
			PR kl=q1.top();LL kv=kl.first;q1.pop();
			ans+=kv+t[i].x,--kl.second;
			if(kl.second) q1.push(kl);
			q2.push((PR){-kv-2*t[i].x,1});//后面可以换洞
		}
		else {
			LL num=t[i].c,sumsum=0;
			while(num&&(!q2.empty())) {
				PR kl=q2.top();LL kv=kl.first;
				if(kv+t[i].w+t[i].x>=0) break;
				q2.pop();LL sum=min(kl.second,num);
				ans+=(kv+t[i].w+t[i].x)*sum,kl.second-=sum,num-=sum;
				if(kl.second) q2.push(kl);
				sumsum+=sum,q1.push((PR){-kv-2*t[i].x,sum});//换兔子
			}
			if(sumsum) q2.push((PR){-t[i].x-t[i].w,sumsum});//换洞
			if(num) q1.push((PR){t[i].w-t[i].x,num});
		}
	}
}
int main()
{
	n=read(),m=read();
	for(RI i=1;i<=n;++i) t[i].x=read(),t[i].w=-1,t[i].c=0;
	for(RI i=1;i<=m;++i)
		t[i+n].x=read(),t[i+n].w=read(),t[i+n].c=read(),sumc+=t[i+n].c;
	if(sumc<(LL)n) {puts("-1");return 0;}
	sort(t+1,t+1+n+m,cmp),work();
	printf("%lld
",ans);
	return 0;
}

树上模拟

题目链接

这道题目的话，我们需要思考一个事情，就是坐标到底要怎么搞？

那么我们可以给每个点设(dis_x)，表示第(x)个点到根的长度。

那么坐标就不是：(dis_x-dis_y)，而是(dis_x+dis_y-2*dis_{lca(x,y)})了。

所以我们考虑在树上从下往上搞。

堆用左偏树。

对于(x)，他找到子树(y)，那么他就可以把自己目前的子树和他对比，即两方的兔子和洞合并，由于贪心局部最优，所以这个子树内的后悔操作已经处理好了。

而两方的兔子洞合并，肯定是各取堆顶是最好的啦，而且有个很显然的事情，就是对于后悔出来的洞和堆，后悔后的兔子和洞肯定也是一个(x)一个(y)，不然从贪心策略讲，(d)变小了，所以减的值变小，那么如果是来自同个集合（(x)或(y)）的配对，肯定会比原来更大，那么就肯定不会出现这种情况，所以我们只需要对于(x)的兔子，直接合并(y)的洞，反之也是。

而且(lca)肯定是(x)，所以先对于(x,y)处理一下洞和兔子，然后再合并，找下一棵子树就行了。

不过这里是洞要求必须进，怎么办，那么我们就把他的权值减上一个(-inf)，要求最优的就一定要进洞吗，然后结果把(-inf)去掉。

你好不好奇为什么这里兔子可以直接添加成一个点，你可以认为是他们进了脚下的洞。

而且对于树上。

rtX[x]=merge(rtX[x],newnode(-v2+2*d,sum));
rtY[y]=merge(rtY[y],newnode(-v1+2*d,sum));

这两句话也是一定不会同时触发的，为什么？

因为如果有一个洞和一个兔子分别和这两个洞和兔子配对，那么一定都经过了(x)，重复，那还不如那两个匹配，这两个原本的匹配在一起（即使最坏也是和原情况相等）。

那么关键是相等怎么判断呢？

设(x,y)配对后，(a)抢(x)，(b)抢(y)

我们不难发现，相等的情况有两个：

1. (a)为(lca(x,y))的祖先，(b)为(lca(x,y))子树内的节点。
2. (a,b)都为子树内的节点。

那么我们就看(b)，(b)抢了(y)后，在(a)选时，相当于问你，是((x,y),(a,b))这样更优，还是((b,y),(a,x)-dis_x+2d)，而(2d>-dis_x+2d>0)，所以贪心会自动选择((x,y),(a,b))，所以我们不用担心。

代码来自https://blog.csdn.net/litble/article/details/88410435

#include<bits/stdc++.h>
using namespace std;
#define RI register int
int read() {
	int q=0;char ch=' ';
	while(ch<'0'||ch>'9') ch=getchar();
	while(ch>='0'&&ch<='9') q=q*10+ch-'0',ch=getchar();
	return q;
}
typedef long long LL;
typedef pair<LL,int> PR;
const int N=250005;
const LL inf=1e12;
int n,tot,SZ;LL ans;
int h[N],ne[N<<1],to[N<<1],X[N],Y[N],rtX[N],rtY[N];LL dis[N],w[N<<1];
struct node{int ls,rs,d;PR v;}tr[N*30];
//申请超大结构体要花很多时间，建议拆成单个数组。

int merge(int a,int b) {
	if(!a||!b) return a|b;
	if(tr[a].v>tr[b].v) swap(a,b);
	tr[a].rs=merge(tr[a].rs,b);
	if(tr[tr[a].rs].d>tr[tr[a].ls].d) swap(tr[a].ls,tr[a].rs);
	tr[a].d=tr[tr[a].rs].d+1;return a;
}
int newnode(LL val,int sum)
	{++SZ,tr[SZ].v=(PR){val,sum},tr[SZ].d=1;return SZ;}

void add(int x,int y,LL z) {to[++tot]=y,ne[tot]=h[x],h[x]=tot,w[tot]=z;}
void mer(int x,int y,LL d) {
	while(rtX[x]&&rtY[y]) {
		LL v1=tr[rtX[x]].v.first,v2=tr[rtY[y]].v.first;
		if(v1+v2-2*d>=0) break;
		int sum=min(tr[rtX[x]].v.second,tr[rtY[y]].v.second);
		ans+=(v1+v2-2*d)*sum;
		tr[rtX[x]].v.second-=sum,tr[rtY[y]].v.second-=sum;
		if(!tr[rtX[x]].v.second) rtX[x]=merge(tr[rtX[x]].ls,tr[rtX[x]].rs);
		if(!tr[rtY[y]].v.second) rtY[y]=merge(tr[rtY[y]].ls,tr[rtY[y]].rs);
		rtX[x]=merge(rtX[x],newnode(-v2+2*d,sum));
		rtY[y]=merge(rtY[y],newnode(-v1+2*d,sum));
	}
}
void dfs(int x,int las) {
	if(X[x]) rtX[x]=newnode(dis[x],X[x]);
	if(Y[x]) rtY[x]=newnode(dis[x]-inf,Y[x]),ans+=1LL*Y[x]*inf;
	for(RI i=h[x];i;i=ne[i]) {
		int y=to[i];if(y==las) continue;
		dis[y]=dis[x]+w[i],dfs(y,x);
		mer(x,y,dis[x]),mer(y,x,dis[x]);
		rtX[x]=merge(rtX[x],rtX[y]),rtY[x]=merge(rtY[x],rtY[y]);
	}
}
int main()
{
	int x,y,z;
	n=read();
	for(RI i=1;i<n;++i)
		x=read(),y=read(),z=read(),add(x,y,z),add(y,x,z);
	for(RI i=1;i<=n;++i) {
		X[i]=read(),Y[i]=read();
		int kl=min(X[i],Y[i]);
		X[i]-=kl,Y[i]-=kl;
	}
	dfs(1,0);
	printf("%lld
",ans);
	return 0;
}

时间复杂度的证明

非树证明

这里我们设计到了如果对于洞和兔子都有分身，那么复杂度是多少？

我个人认为是(O(nlogn))带一些常数的，分析是基于算法的分析。

对于兔子。

他找到了一个洞，如果他目前的容量小于这个洞的话，那么这个洞被拆成两个部分，然后(break)，而对于小于等于，则是把这个洞和兔子匹配，然后生成了一个新的洞，表示抢兔子，而抢洞的则是在最后添加。

如果发现权值大于(0)，则直接拿这些兔子做一个点插入堆。

观察整个过程，貌似对于一个兔子产生的点的个数级是(O(1))的。

而对于洞，也可以这样分析。

所以就是(O(nlogn))。

树上

这里设计到了合并。

就不是一个个合并了。

我们看一下对于兔子和洞的合并，如果从两个堆中取了兔子和动，并且塞了后悔操作回去，这个后悔操作会不会在本次合并中再次被采用呢？

如果其中一个后悔操作是和原堆中的节点(x)合并，那么为什么在配对的时候堆顶不是(x)。

所以我们只需要考虑为什么不是一个后悔操作对应一个后悔操作（而且肯定不是原来的一对后悔操作，肯定是不同配对的后悔操作）：

那么为什么(a,x)在配对的时候堆顶会是(b,y)呢？这点需要考虑一下QMQ。

所以每次只会匹配兔子和洞堆的大小的(min)。

而且，对于每次堆顶合并，最多会生成三个点。（多了一个点）而真正会参与后面操作的则是两个点，所以我们多出来的点就是合并次数。

那么这个(min)要怎么搞呢？

对于两个点数为(x,y(x<=y))的集合，那么他们兔子堆和洞堆中的可以操作的点是(O(n))的。

---

那么就是(a+b=x,c+d=y)，求(min(a,c)+min(b,d))的最大值。

(min(a,c)+min(x-a,y-c))

当(a<=c,x-a<=y-c)时，那么就是(x)。

当(a<=c,x-a>=y-c)时，那么合并次数(<=x)。

当(a>=c,x-a<=y-c)时，那么合并次数(<=x)。

所以就是(x)。

---

由于集合合并只会记录最小的集合，那么最坏情况就是两个集合大小相等。

那么就是一个完全二叉树的情况。

而这种情况就是多产生了(nlogn)个节点，而还要计算左偏树，所以就是(O(nlog^2n))

不知道是不是对的QAQ。

小结

模拟费用流一般是模拟退流操作

而且对于兔子和洞选择的必要性可以添加点，如某些兔子可以不选，那么就添加一个权值为(0)的洞，选了这些洞就是不选，而如果必须选，就添加(inf)，洞必须进，就把权值(-inf)，都是些小技巧。