bzoj 1834

网络流的模板题

首先第一问我们直接用dinic搞就行了，费用直接存为0（时间上界非常松，这道题是能过），然后第二问我们只需要在第一问

的残余网络上加一个源点，源点指向1号点，容量为k，费用为0，然后对于之前的每一条边，建一个相同的边

容量为无穷大，费用为原来的费用。

//By BLADEVIL
var
    pre, other, len, w            :array[..] of longint;
    last                        :array[..] of longint;
    l                            :longint;
    n, m, k                     :longint;
    father, que, dis            :array[..] of longint;
    flag                        :array[..] of boolean;
    a, b, c, d                    :array[..] of longint;
    cost                        :longint;

function min(a,b:longint):longint;
begin
    if a>b then min:=b else min:=a;
end;

procedure connect(a,b,c,d:longint);
begin
    inc(l);
    pre[l]:=last[a];
    last[a]:=l;
    other[l]:=b;
    len[l]:=c;
    w[l]:=d;
end;

procedure init;
var
    i                            :longint;

begin
    read(n,m,k);
    l:=;
    for i:= to m do read(a[i],b[i],c[i],d[i]);
    for i:= to m do
    begin
        connect(a[i],b[i],c[i],);
        connect(b[i],a[i],,);
    end;
end;

function bfs:boolean;
var
    q, p                        :longint;
    cur                            :longint;
    h, t                        :longint;
begin
    fillchar(dis,sizeof(dis),);
    h:=; t:=;
    que[]:=; dis[]:=;
    while t<>h do
    begin
        inc(h);
        cur:=que[h];
        q:=last[cur];
        while q<> do
        begin
            p:=other[q];
            if (len[q]>) and (dis[p]=) then
            begin
                inc(t);
                que[t]:=p;
                dis[p]:=dis[cur]+;
                if p=n then exit(true);
            end;
            q:=pre[q];
        end;
    end;
    exit(false);
end;

function dinic(x,flow:longint):longint;
var
    q, p                        :longint;
    rest, tmp                    :longint;
begin
    if x=n then exit(flow);
    rest:=flow;
    q:=last[x];
    while q<> do
    begin
        p:=other[q];
        if (len[q]>) and (rest>) and (dis[p]=dis[x]+) then
        begin
            tmp:=dinic(p,min(len[q],rest));
            dec(rest,tmp);
            dec(len[q],tmp);
            inc(len[q xor ],tmp);
        end;
        q:=pre[q];
    end;
    exit(flow-rest);
end;

procedure spfa;
var
    q, p                        :longint;
    h, t, cur                    :longint;

begin
    fillchar(flag,sizeof(flag),false);
    filldword(dis,sizeof(dis) div ,maxlongint div );
    h:=; t:=;
    que[]:=n+;
    dis[n+]:=;
    while h<>t do
    begin
        h:=h mod +;
        cur:=que[h];
        flag[cur]:=false;
        q:=last[cur];
        while q<> do
        begin
            if len[q]> then
            begin
                p:=other[q];
                if dis[cur]+w[q]<dis[p] then
                begin
                    dis[p]:=dis[cur]+w[q];
                    father[p]:=q;
                    if not flag[p] then
                    begin
                        t:=t mod +;
                        que[t]:=p;
                        flag[p]:=true;
                    end;
                end;
            end;
            q:=pre[q];
        end;
    end;
end;

procedure update;
var
    cur                            :longint;
    low                            :longint;
begin
    cur:=n;
    low:=maxlongint div ;
    while cur<>n+ do
    begin
        low:=min(low,len[father[cur]]);
        cur:=other[father[cur] xor ];
    end;
    cur:=n;
    while cur<>n+ do
    begin
        inc(cost,low*w[father[cur]]);
        dec(len[father[cur]],low);
        inc(len[father[cur] xor ],low);
        cur:=other[father[cur] xor ];
    end;
end;

procedure main;
var
    ans                            :longint;
    i                            :longint;

begin
    ans:=;
    while bfs do
        ans:=ans+dinic(,maxlongint div );

    for i:= to m do
    begin
        connect(a[i],b[i],maxlongint div ,d[i]);
        connect(b[i],a[i],,-d[i]);
    end;

    connect(n+,,k,);
    connect(,n+,,);
    while true do
    begin
        spfa;
        if dis[n]=maxlongint div  then break;
        update;
    end;
    writeln(ans,' ',cost);
end;

begin
    init;
    main;
end.