【傳送門：BZOJ1834】

簡要題意：

　　給出n個點，m條邊的有向圖，給出每條邊的流量c和費用w（每條邊都可以擴增自己的流量，每增加1流量就需要w的花費）

　　求出從1到n的最大流，並且求出使最大流+k的最小花費

題解：

　　第一個答案用網絡流直接求肯定是沒問題

　　第二個答案就要用費用流來做

　　首先因為求第一個答案的時候已經將能構成最大流的路徑上的每條邊的流量都減少了，所以剩下了一個殘留圖

　　我們會發現其實殘留圖上還有一些邊的流量沒有流盡，那麽我們就用每條邊的剩余流量建一條流量為當前剩余流量而費用為0的邊，並且建一條流量無限，費用為原費用的邊，如果這條邊已經流盡了，那麽我們直接建一條流量無限，費用為原費用的邊，而實際操作中是可以把這兩個步驟合並的

　　而其實我們並不需要將所有邊都重新建，只需要每條邊都加建一條流量無限，費用為原費用的邊，而剩余流量所建的邊就是殘留圖上的邊

　　最後我們還要新建一個匯點，使n連向匯點，流量為k，費用為0，這樣就可以保證總流量不超過k

參考代碼：

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
struct node
{
    int x,y,c,d,next,other;
    node()
    {
        d
 
=0;
    }
}a[21000];int len,last[5100];
void ins(int x,int y,int c,int d)
{
    int k1=++len,k2=++len;
    a[k1].x=x;a[k1].y=y;a[k1].c=c;a[k1].d=d;
    a[k1].next=last[x];last[x]=k1;
    a[k2].x=y;a[k2].y=x;a[k2].c=0;a[k2].d=-d;
    a[k2].next=last[y];last[y]=k2;
    a[k1].other=k2;
    a[k2].other
 
=k1;
}
int st,ed;
int h[5100],list[5100];
bool bt_h()
{
    int head=1,tail=2;
    memset(h,0,sizeof(h));
    h[st]=1;
    list[1]=st;
    while(head!=tail)
    {
        int x=list[head];
        for(int k=last[x];k;k=a[k].next)
        {
            int y=a[k].y;
            if(h[y]==0&&a[k].c>0)
            {
                h[y]=h[x]+1;
                list[tail++]=y;
            }
        }
        head++;
    }
    if(h[ed]==0) return false;
    else return true;
}
int findflow(int x,int f)
{
    if(x==ed) return f;
    int s,t=0;
    for(int k=last[x];k;k=a[k].next)
    {
        int y=a[k].y;
        if(h[y]==(h[x]+1)&&a[k].c>0&&f>t)
        {
            s=findflow(y,min(a[k].c,f-t));
            t+=s;
            a[k].c-=s;a[a[k].other].c+=s;
        }
    }
    if(t==0) h[x]=0;
    return t;
}
int d[5100];
bool v[5100];
int ans;
int pos[5100],pre[5100];
bool spfa()
{
    for(int i=st;i<=ed;i++) d[i]=999999999;
    d[st]=0;
    memset(v,false,sizeof(v));
    v[st]=true;
    int head=1,tail=2;
    list[1]=st;
    while(head!=tail)
    {
        int x=list[head];
        for(int k=last[x];k;k=a[k].next)
        {
            int y=a[k].y;
            if(a[k].c>0&&d[y]>d[x]+a[k].d)
            {
                d[y]=d[x]+a[k].d;
                pos[y]=x;
                pre[y]=k;
                if(v[y]==false)
                {
                    v[y]=true;
                    list[tail++]=y;
                }
            }
        }
        head++;
        v[x]=false;
    }
    if(d[ed]==999999999) return false;
    else return true;
}
void Flow()
{
    while(spfa())
    {
        ans+=d[ed];
        for(int x=ed;x!=st;x=pos[x])
        {
            a[pre[x]].c--;
            a[a[pre[x]].other].c++;
        }
    }
}
int x[5100],y[5100],c[5100],w[5100];
int main()
{
    int n,m,k;
    scanf("%d%d%d",&n,&m,&k);
    len=0;memset(last,0,sizeof(last));
    st=1;ed=n;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d%d",&x[i],&y[i],&c[i],&w[i]);
        ins(x[i],y[i],c[i],0);
    }
    ans=0;
    while(bt_h()==true)
    {
        ans+=findflow(st,999999999);
    }
    printf("%d ",ans);
    for(int i=1;i<=m;i++) ins(x[i],y[i],k,w[i]);
    ed=n+1;
    ins(n,n+1,k,0);
    ans=0;
    Flow();
    printf("%d\n",ans);
    return 0;
}

BZOJ1834: [ZJOI2010]network 網絡擴容