bzoj1834[ZJOI2010]network 网络扩容【最大流+费用流】

第一问很简单，裸着上

第二问费用流，主要是建图，那么可以从第一问的残留网络上继续建图，对残留网络上的每一条边建一条容量是∞费用是w的边（反向弧容量为0，费用为-w），然后建一个超级源点，从超级源向1建一条容量为k，费用为0的边（用来控制），对这个图进行最小费用最大流算法。

       最小费用最大流操作：

       1.首先要对于这道题的图来说，有的边需要花费费用，而有的又不用，而不用扩容的边费用为0，需要扩容的边费用为w，容量无限，这就是本题这样建图的原因。

       2.对于残留网络进行费用最短路SPFA算法，不用扩容的边一定会选费用为0的边，然后记录路径，找最小容量对可行路进行增流，更新ans

/**************************************************************
    Problem: 1834
    User: BPM136
    Language: C++
    Result: Accepted
    Time:52 ms
    Memory:2520 kb
****************************************************************/
 
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<bitset>
#define LL long long
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define efo(i,x) for(int i=last[x];i!=0;i=e[i].next)
using namespace std;
inline LL read()
{
    LL d=0,f=1;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){d=d*10+s-'0';s=getchar();}
    return d*f;
}
#define N 1005
#define M 5005
#define inf 100000007
struct edge
{
    int x,y,next,w,c,f;
}e[M*10];
int last[N*5],ne=1;
int n,m,mn,ans=0;
 
void add11(int x,int y,int f,int w)
{
    e[++ne].x=x;e[ne].y=y;e[ne].f=f;e[ne].w=w;e[ne].next=last[x];last[x]=ne;
}
void add12(int x,int y,int f,int w)
{
    add11(x,y,f,w);add11(y,x,0,-w);
}
 
void init()
{
    n=read(),m=read();mn=read();
    fo(i,1,m)
    {
        int x=read(),y=read(),w=read(),c=read();
        add12(x,y,w,c);
    }
}
 
int q[N*9],high[N];
bitset<N>inq;
bool bfs(int s,int tt)
{
    inq.reset();
    memset(high,0,sizeof(high));
    int h=0,t=1;
    q[1]=s;inq[s]=1;high[s]=1;
    while(h<t)
    {
        int now=q[++h];
        if(now==tt)return 1;
        efo(i,now)
        if(e[i].f&&high[e[i].y]==0)
        {
            high[e[i].y]=high[now]+1;
            q[++t]=e[i].y;
        }
//      inq[now]=0;
    }
    return 0;
}
 
int dfs(int s,int maxf,int t)
{
    if(s==t)return maxf;
    int ret=0,f;
    efo(i,s)
    if(e[i].f&&high[e[i].y]==high[s]+1)
    {
        f=dfs(e[i].y,min(maxf-ret,e[i].f),t);
        e[i].f-=f;
        e[i^1].f+=f;
        ret+=f;
        if(ret==maxf)return ret;
    }
    return ret;
}
 
int dinic(int s,int t)
{
    int ret=0;
    while(bfs(s,t))ret+=dfs(s,inf,t);
    return ret;
}
 
void add21(int x,int y,int f,int c)
{
    e[++ne].x=x;e[ne].y=y;e[ne].f=f;e[ne].c=c;e[ne].next=last[x];last[x]=ne;
}
void add22(int x,int y,int f,int c)
{
    add21(x,y,f,c);add21(y,x,0,-c);
}
 
void build()
{
    int t=ne;
    fo(i,2,t)
    if(i%2==0)
    add22(e[i].x,e[i].y,inf,e[i].w);
     
    add21(n+1,1,mn,0);
}
 
int dis[N],pre[N],lo[N];
bool spfa(int s,int tt)
{
    inq.reset();
    fo(i,0,N-1)dis[i]=inf;
    memset(pre,0,sizeof(pre));
    memset(lo,0,sizeof(lo));
    int h=0,t=1;
    q[1]=s;dis[s]=0;inq[s]=1;
    while(h<t)
    {
        int now=q[++h];
        efo(i,now)
        if(e[i].f&&dis[now]+e[i].c<dis[e[i].y])
        {
            dis[e[i].y]=dis[now]+e[i].c;
            pre[e[i].y]=now;
            lo[e[i].y]=i;
            if(inq[e[i].y]==0)
            {
                inq[e[i].y]=1;
                q[++t]=e[i].y;
            }
        }
        inq[now]=0;
    }
    if(dis[tt]==inf)return 0;
    else return 1;
}
 
void mcf(int s,int t)
{
    while(spfa(s,t))
    {
        int x=t,mi=inf;
        while(pre[x]!=0)
        {
            mi=min(mi,e[lo[x]].f);
            x=pre[x];
        }
        x=t;
        while(pre[x]!=0)
        {
            ans+=mi*e[lo[x]].c;
            e[lo[x]].f-=mi;
            e[lo[x]^1].f+=mi;
            x=pre[x];
        }
    }
}   
 
int main()
{
    init();
    ans=dinic(1,n);
    printf("%d ",ans);
    ans=0;
    build();
    mcf(n+1,n);
    printf("%d",ans);
    return 0;
}