ZJOI2010——network 网络扩容（费用流）

网络扩容(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
)return 1; else return 0;
//if(dist
==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
*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;
}