网络扩容(network.c/cpp/pas)
时限:1秒
【问题描述】
给定一张有向图,每条边都有一个容量C和一个扩容费用W。这里扩容费用是指将容量扩大1所需的费用。求:
1、 在不扩容的情况下,1到N的最大流;
2、 将1到N的最大流增加K所需的最小扩容费用。
【输入格式】network.in
输入文件的第一行包含三个整数N,M,K,表示有向图的点数、边数以及所需要增加的流量。
接下来的M行每行包含四个整数u,v,C,W,表示一条从u到v,容量为C,扩容费用为W的边。
【输出格式】network.out
输出文件一行包含两个整数,分别表示问题1和问题2的答案。
【输入样例】
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
【输出样例】
13 19
【数据规模】
30%的数据中,N<=100
100%的数据中,N<=1000,M<=5000,K<=10
解析:
这是一道很裸的费用流。。。但对于我这个初接触费用流的菜鸟来说,还是调了很久。。。
基本思路就是先求出最大流,再加带费用,流量限制为K的边,把残量网络走完,用SPFA求最小费用最大流。。。
代码:
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
queue<int>q;
const int inf=2100000000;
struct node
{
int u,c,v,w,next;
}edge[20010];
int head[1010],pre[1010],dist[1010];
bool vis[1010];
int n,m,k,l=0,ans;
int g[1000+10][1000+10],cost[1000+10][1000+10];
int d[1000+10],sumd[1010];
void addedge(int u,int v,int c,int w)
{
edge[l].c=c;
edge[l].u=u;
edge[l].v=v;
edge[l].w=w;
edge[l].next=head[u];
head[u]=l++;
edge[l].c=0;
edge[l].u=v;
edge[l].v=u;
edge[l].w=0-w;
edge[l].next=head[v];
head[v]=l++;
}
bool SPFA()
{
while (!q.empty()) q.pop();
memset(pre,0,sizeof(pre));
memset(vis,0,sizeof(vis));
memset(dist,0x3f,sizeof(dist));
//for(int i=1;i<=n;i++)dist[i]=inf;
dist[0]=0;
vis[0]=1;
q.push(0);
while(!q.empty())
{
int u=q.front(); q.pop();
vis[u]=0;
for(int i=head[u];i!=-1;i=edge[i].next)
{
int v=edge[i].v;
if(edge[i].c>0 && edge[i].w+dist[u]<dist[v])
{
dist[v]=dist[u]+edge[i].w;
pre[v]=i;
if(!vis[v])
{
q.push(v);
vis[v]=1;
}
}
}
}
if(pre[n])return 1; else return 0;
//if(dist[n]==inf)return 0;else return 1;
}
void readdata()
{
freopen("network.in","r",stdin);
freopen("network.out","w",stdout);
scanf("%d%d%d",&n,&m,&k);
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++) cost[i][j]=inf;
for(int i=1;i<=m;i++)
{
int u,v,c,w;
scanf("%d%d%d%d",&u,&v,&c,&w);
g[u][v]+=c;
cost[u][v]=min(cost[u][v],w);
}
}
int max_flow(int u,int flow)
{
if(u==n)return flow;
int sum=0;
for(int i=head[u];i!=-1;i=edge[i].next)
{
int v=edge[i].v;
if(edge[i].c && d[u]==d[v]+1)
{
int t=max_flow(v,min(flow-sum,edge[i].c));
edge[i].c-=t;edge[i^1].c+=t;
sum+=t;
if(sum==flow)return flow;
}
}
if(d[1]==n) return sum;
sumd[d[u]]--;
if(sumd[d[u]]==0)d[1]=n;
sumd[++d[u]]++;
return sum;
}
void MinC_MaxF()
{
ans=0;
while(SPFA())
{
int u=n;
int minn=inf;
while(u!=0)
{
//minn=min(minn,edge[u].c);
if(edge[pre[u]].c<minn)minn=edge[pre[u]].c;
u=edge[pre[u]].u;
}
u=n;
while(u!=0)
{
edge[pre[u]].c-=minn;
edge[pre[u]^1].c+=minn;
u=edge[pre[u]].u;
}
ans+=dist[n]*minn;
}
}
void work()
{
memset(head,-1,sizeof(head));
ans=0; sumd[0]=n;
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
if(g[i][j])
{addedge(i,j,g[i][j],0);}
}
while(d[1]<n)
{
ans+=max_flow(1,inf);
}
cout<<ans<<' ';
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
if(g[i][j]){
addedge(i,j,k,cost[i][j]);
}
}
addedge(0,1,k,0);
MinC_MaxF();
cout<<ans;
}
int main()
{
readdata();
work();
return 0;
}