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[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;
}