[ZJOI2010]网络扩容

题目描述

给定一张有向图，每条边都有一个容量C和一个扩容费用W。这里扩容费用是指将容量扩大1所需的费用。求： 1、 在不扩容的情况下，1到N的最大流； 2、 将1到N的最大流增加K所需的最小扩容费用。

输入输出格式

输入格式：

输入文件的第一行包含三个整数N,M,K，表示有向图的点数、边数以及所需要增加的流量。 接下来的M行每行包含四个整数u,v,C,W，表示一条从u到v，容量为C，扩容费用为W的边输出格式：

输出文件一行包含两个整数，分别表示问题1和问题2的答案。input

5 8 2
1 2 5 8
2 5 9 9
5 1 6 2
5 1 1 8
1 2 8 7
2 5 4 9
1 2 1 1
1 4 2 1

output

13 19

建边，先跑一遍最大网络流，再在残余网络上重新建边，容量为K，重新构造一个汇点（与N相连，费用为0，容量为K)和源点(与1相连，费用为0，容量为K),跑最小费用流就行了。

开数组一定要开够，建边要开4倍；

跑完网络流不能把图给清空了；

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int z=5005;
const int l=1005;
int a[5005],b[5005],c[5005],d[5005];
int q[z*15],q1[z*15],vis[l],dis[l],dis1[l],fa[l],bian[l];
int n,m,k,fei,ans1,huan,hui;
int nex[10*z],tov[10*z],tow[10*z],tof[10*z],h[l],tp=1;
void add(int x,int y,int w,int f)
{
	tp++;
	tof[tp]=f;
	tow[tp]=w;
	tov[tp]=y;
	nex[tp]=h[x];
	h[x]=tp;
	tp++;
	tof[tp]=(-1)*f;
	tow[tp]=0;
	tov[tp]=x;
	nex[tp]=h[y];
	h[y]=tp;
}
bool bfs()
{
	memset (dis1,0,sizeof(dis1));
	memset(q1,0,sizeof(q1));
	memset(vis,0,sizeof(vis));
	int tail=1,head=0;
     q1[tail]=huan;
     vis[huan]=1;
     while(head<tail)
     {
	       head++; 
     	int x=q1[head];
     	for(int i=h[x];i;i=nex[i])
     	{
     		int v=tov[i];
     		if(vis[v]==0&&tow[i]>0)
     		{
     			vis[v]=1;
     			tail++;
     			q1[tail]=v;
     			dis1[v]=dis1[x]+1;
     		}
     	}
     }
     return vis[hui];
}
int dfs(int x,int delta)
{
	if(x==hui)
	{
		return delta;
	}
	int res=0;
	for(int i=h[x];i;i=nex[i])
	{
		int v=tov[i];
		if(dis1[v]==dis1[x]+1&&tow[i]>0)
		{	
		int dd=dfs(v,min(delta,tow[i]));
		delta-=dd;
		res+=dd;
		tow[i]-=dd;
		tow[i^1]+=dd;
		}
	
	}
	return res;
}
int  spfa()
{
	memset(vis,0,sizeof(vis));
	memset(q,0,sizeof(q));
    memset(dis,127/3,sizeof(dis)); 
	 int tail=1,head=0;
	 q[tail]=huan;
	 vis[huan]=1;
	 dis[huan]=0;
    while(head<tail)
    {
    	head++;
    	int x=q[head];
    	for(int i=h[x];i;i=nex[i])
    	{
    		int v=tov[i];
    		if(tow[i]!=0&&dis[v]>dis[x]+tof[i])
    		{
    			dis[v]=dis[x]+tof[i];
    			bian[v]=i;
    			fa[v]=x;
    			if(vis[v]==0)
    			{	
				vis[v]=1;
    			tail++;
    			q[tail]=v;
    			}
    		
    		}
    	}
    	vis[x]=0;
    }
    return dis[hui]<dis[n+2];	
}
void liu()
{
int u=hui;
int delta=1e9;
while(u!=huan)
{
	delta=min(delta,tow[bian[u]]);
	u=fa[u];
}
u=hui;
while(u!=huan)
{
	tow[bian[u]]-=delta;
	tow[bian[u]^1]+=delta;
	u=fa[u];
}
 
fei+=delta*dis[hui];
ans1+=delta;
}
int main() 
{
	cin>>n>>m>>k;
	for(int i=1;i<=m;i++)
	{
		
		scanf("%d%d%d%d",&a[i],&b[i],&c[i],&d[i]);
		add(a[i],b[i],c[i],0);
	}
	hui=n;
	huan=1;
	int ans=0;
	while(bfs())
	{
		ans+=dfs(huan,1e9);
	}
	huan=0;
	hui=n+1;
	add(huan,1,k,0);
	add(n,n+1,k,0);
    for(int i=1;i<=m;i++)
	{
		add(a[i],b[i],k,d[i]);
	}
	while(spfa())
	{
		liu();
	}
	cout<<ans<<endl;
	cout<<fei;
	return 0;
}

网络流Dinic复杂度是n^2*m;