bzoj1497

这道题让我涨姿势了

对于这类问题，我们称作最大权闭合图问题

就是每个点都有一个点权，要求选择一个点集，其中每个点的指向的点也在点集中，使这样一个点权和最大

对于这种问题，我们添加源点s，汇点t

对于点i，如果点权w是正的，我们连边s--->i，流量为w

如果点权w是负的，我们连边i--->t，流量为-w

然后我们我们原图中所有边流量设为inf即可

最后的答案=正点权和-最小割（最大流）

对于这道题，我们把用户和中转站看成点，

对于每个用户，我们显然要由它指向对应的两个中转站，然后做最大权闭合图即可

但是，这样做会tle，

分析一下，为什么呢？因为有多达50000个用户

再仔细观察题目，一共最多只有5000个中转站，

我们知道，最大流的效率取决于找增广路的效率

对于这幅图，我们不难发现，瓶颈边更容易出现在中转站一边

于是我们可以反向建图，这不改变网络的最小割，并且能大大减少增广的次数

反向建图是一个很重要的优化方法

const inf=10000007;
type node=record
       next,flow,point:longint;
     end;

var edge:array[0..2000010] of node;
    p,h,numh,cur,pre:array[0..60010] of longint;
    n,m,i,j,t,x,y,z,len,s:longint;

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

procedure add(x,y,f:longint);
  begin
    inc(len);
    edge[len].point:=y;
    edge[len].flow:=f;
    edge[len].next:=p[x];
    p[x]:=len;
  end;

function sap:longint;
  var u,i,j,q,neck,tmp,s:longint;
  begin
    u:=0;
    numh[0]:=t+1;
    sap:=0;
    while h[0]<t+1 do
    begin
      if u=t then
      begin
        neck:=inf;
        i:=0;
        while i<>t do
        begin
          j:=cur[i];
          if neck>edge[j].flow then
          begin
            neck:=edge[j].flow;
            s:=i;
          end;
          i:=edge[j].point;
        end;
        i:=0;
        while i<>t do
        begin
          j:=cur[i];
          dec(edge[j].flow,neck);
          inc(edge[j xor 1].flow,neck);
          i:=edge[j].point;
        end;
        sap:=sap+neck;
        u:=s;
      end;
      q:=-1;
      i:=p[u];
      while i<>-1 do
      begin
        j:=edge[i].point;
        if (edge[i].flow>0) and (h[u]=h[j]+1) then
        begin
          q:=i;
          break;
        end;
        i:=edge[i].next;
      end;
      if q<>-1 then
      begin
        cur[u]:=i;
        pre[j]:=u;
        u:=j;
      end
      else begin
        dec(numh[h[u]]);
        if numh[h[u]]=0 then exit;
        tmp:=t+1;
        i:=p[u];
        while i<>-1 do
        begin
          j:=edge[i].point;
          if edge[i].flow>0 then tmp:=min(tmp,h[j]);
          i:=edge[i].next;
        end;
        h[u]:=tmp+1;
        inc(numh[h[u]]);
        if u<>0 then u:=pre[u];
      end;
    end;
  end;

begin
  readln(n,m);
  t:=n+m+1;
  len:=-1;
  fillchar(p,sizeof(p),255);
  for i:=1 to n do
  begin
    read(x);
    add(0,i,x);
    add(i,0,0);
  end;
  for i:=1 to m do
  begin
    readln(x,y,z);
    s:=s+z;
    add(n+i,t,z);
    add(t,n+i,0);
    add(x,n+i,inf);
    add(n+i,x,0);
    add(y,n+i,inf);
    add(n+i,y,0);
  end;
  writeln(s-sap);
end.