bzoj1497

这道题让我涨姿势了

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

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

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

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

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

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

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

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

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

但是，这样做会tle，

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

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

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

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

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

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

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

 var edge:array[..] of node;
     p,h,numh,cur,pre:array[..] 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:=;
     numh[]:=t+;
     sap:=;
     while h[]<t+ do
     begin
       if u=t then
       begin
         neck:=inf;
         i:=;
         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:=;
         while i<>t do
         begin
           j:=cur[i];
           dec(edge[j].flow,neck);
           inc(edge[j xor ].flow,neck);
           i:=edge[j].point;
         end;
         sap:=sap+neck;
         u:=s;
       end;
       q:=-;
       i:=p[u];
       while i<>- do
       begin
         j:=edge[i].point;
         if (edge[i].flow>) and (h[u]=h[j]+) then
         begin
           q:=i;
           break;
         end;
         i:=edge[i].next;
       end;
       if q<>- then
       begin
         cur[u]:=i;
         pre[j]:=u;
         u:=j;
       end
       else begin
         dec(numh[h[u]]);
         if numh[h[u]]= then exit;
         tmp:=t+;
         i:=p[u];
         while i<>- do
         begin
           j:=edge[i].point;
           if edge[i].flow> then tmp:=min(tmp,h[j]);
           i:=edge[i].next;
         end;
         h[u]:=tmp+;
         inc(numh[h[u]]);
         if u<> then u:=pre[u];
       end;
     end;
   end;

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