bzoj 2039 最小割模型

　　比较明显的网络流最小割模型，对于这种模型我们需要先求获利的和，然后减去代价即可。

　　我们对于第i个人来说， 如果选他，会耗费A[I]的代价，那么(source,i,a[i])代表选他之后的代价，如果不选他，我们会产生Σw[i][j] 1<=j<=n的代价，也就是这么多的利益我们无法得到，然后对于两个人的互相影响，连边(i,j,2*w[i][j])，代表如果不选i，选j的话，本来i中选j的利益得不到，又要损失j对i的影响为w[i][j]。所以共计损失2*w[i][j]。之后求最小割=最大流就行了。

/**************************************************************

    Problem: 2039

    User: BLADEVIL

    Language: Pascal

    Result: Accepted

    Time:860 ms

    Memory:47112 kb

****************************************************************/

 

//By BLADEVIL

var

    n                           :longint;

    pre, other, len             :array[0..4000010] of longint;

    last                        :array[0..1010] of longint;

    l                           :longint;

    source, sink                :longint;

    que, d                      :array[0..1010] of longint;

    ans                         :longint;

     

function min(a,b:longint):longint;

begin

    if a>b then min:=b else min:=a;

end;

     

procedure connect(x,y,z:longint);

begin

    inc(l);

    pre[l]:=last[x];

    last[x]:=l;

    other[l]:=y;

    len[l]:=z;

end;

     

procedure init;

var

    i, j                        :longint;

    x                           :longint;

    sum                         :longint;

begin

    read(n);

    source:=n+2; sink:=source+1; l:=1;

    for i:=1 to n do

    begin

        read(x);

        connect(source,i,x);

        connect(i,source,0);

    end;

    for i:=1 to n do

    begin

        sum:=0;

        for j:=1 to n do

        begin

            read(x);

            if x=0 then continue;

            sum:=sum+x;

            connect(i,j,x<<1);

            connect(j,i,0);

            ans:=ans+x;

        end;

        connect(i,sink,sum);

        connect(sink,i,0);

    end;

end;

 

function bfs:boolean;

var

    h, t, cur                   :longint;

    q, p                        :longint;

begin

    fillchar(d,sizeof(d),0);

    h:=0; t:=1;

    que[1]:=source;

    d[source]:=1;

    while h<t do

    begin

        inc(h);

        cur:=que[h];

        q:=last[cur];

        while q<>0 do

        begin

            p:=other[q];

            if (len[q]>0) and (d[p]=0) then

            begin

                inc(t);

                que[t]:=p;

                d[p]:=d[cur]+1;

                if p=sink then exit(true);

            end;

            q:=pre[q];

        end;

    end;

    exit(false);

end;

 

function dinic(x,flow:longint):longint;

var

    rest, tmp                   :longint;

    q, p                        :longint;

begin

    if x=sink then exit(flow);

    rest:=flow;

    q:=last[x];

    while q<>0 do

    begin

        p:=other[q];

        if (len[q]>0) and (d[p]=d[x]+1) and (rest>0) then

        begin

            tmp:=dinic(p,min(len[q],rest));

            dec(rest,tmp);

            dec(len[q],tmp);

            inc(len[q xor 1],tmp);

        end;

        q:=pre[q];

    end;

    exit(flow-rest);

end;

 

procedure main;

begin

    while bfs do ans:=ans-dinic(source,maxlongint div 10);

    writeln(ans);

end;

 

begin

    init;

    main;

end.