bzoj2597

非常好的网络流题目

首先这里用到了求补集的思想，我们可以先求不满足的三元对的情况

设A-->B代表A赢B

由于最后所有胜负关系都确定，一定是一个完全图，
所以任意一个不合法的三元对，单独取出来一定是1个点出度为2，一个点入度为2，另一点出度1入度1
不妨考虑入度为2的点，从这个点的入边中任意取两条不同的，一定唯一构成一个不合法的三元对
因此合法方案数=C(3,n)-sigma(C(2,in[i]))=C(3,n)+sigma(in[i])/2-sigma(in[i]^2)/2
=C(3,n)+m/2-sigma(in[i]^2)/2=C(3,n)+(n-1)n/4-sigma(in[i]^2)/2
由于前两个是定值，所以我们只要最小化sigma(in[i]^2)/2
不难想到吧每个未确定的关系看做一个点i，s-->i流量为1
i向连接的两个点各连边流量为1的边，费用都为0
关键是点连向t的边，这里与流量二次成正比
考虑到1+3+5+……2n-1=n^2
我们考虑流量n拆成n条流量为1的边，费用依次是1,3,5……2n-1
然后建图跑最小费用流即可
最后求方案也很简单，看做网络流后，找到每个关系的流量流向哪个点即可

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

 var edge:array[..] of node;
     q:array[..] of longint;
     s,p,cur,pre,d:array[..] of longint;
     v:array[..] of boolean;
     a:array[..,..] of longint;
     x,i,j,n,m,t,len,ans:longint;

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

 function spfa:boolean;
   var x,f,r,i,y:longint;
   begin
     f:=;
     r:=;
     q[]:=;
     fillchar(v,sizeof(v),false);
     v[]:=true;
     for i:= to t do
       d[i]:=inf;
     d[]:=;
     while f<=r do
     begin
       x:=q[f];
       v[x]:=false;
       i:=p[x];
       while i<>- do
       begin
         y:=edge[i].point;
         if edge[i].flow> then
           if d[y]>d[x]+edge[i].cost then
           begin
             d[y]:=d[x]+edge[i].cost;
             pre[y]:=x;
             cur[y]:=i;
             if not v[y] then
             begin
               v[y]:=true;
               inc(r);
               q[r]:=y;
             end;
           end;
         i:=edge[i].next;
       end;
       inc(f);
     end;
     if d[t]=inf then exit(false) else exit(true);
   end;

 function mincost:longint;
   var i,j:longint;
   begin
     mincost:=;
     while spfa do
     begin
       i:=t;
       mincost:=mincost+d[t];
       while i<> do
       begin
         j:=cur[i];
         dec(edge[j].flow);
         inc(edge[j xor ].flow);
         i:=pre[i];
       end;
     end;
   end;

 function find(x:longint):longint;
   var i:longint;
   begin
     i:=p[x];
     while i<>- do
     begin
       if (edge[i].flow=) and (edge[i].point<>) then
         exit(edge[i].point);  //看流向哪个点，哪个点就输了
       i:=edge[i].next;
     end;
     exit(-);
   end;

 begin
   len:=-;
   fillchar(p,sizeof(p),);
   readln(n);
   for i:= to n do
   begin
     for j:= to n do
     begin
       read(a[i,j]);
       if (i<j) then  //避免重复
       begin
         if a[i,j]= then
         begin
           inc(m);
           add(,m+n,,);
           add(n+m,,,);
           add(m+n,i,,);
           add(i,m+n,,);
           add(m+n,j,,);
           add(j,m+n,,);
         end
         else if a[i,j]= then inc(s[j])
         else inc(s[i]);
       end;
     end;
     readln;
   end;
   t:=m+n+;
   ans:=n*(n-) div +n*(n-)*(n-) div ;
   for i:= to n do
   begin
     ans:=ans-sqr(s[i]);  //已经有确定的入度k的点就相当于与t相连的前k条边已经满流了
     for j:=s[i]+ to n do
     begin
       add(i,t,,j*-);
       add(t,i,,-j*);
     end;
   end;
   ans:=(ans-mincost) div ;
   writeln(ans);
   m:=;
   for i:= to n- do
     for j:=i+ to n do
       if a[i,j]= then
       begin
         inc(m);
         x:=find(m+n);
         if x=i then
         begin
           a[i,j]:=;
           a[j,i]:=;
         end
         else begin
           a[i,j]:=;
           a[j,i]:=;
         end;
       end;

   for i:= to n do
   begin
     for j:= to n do
       write(a[i,j],' ');
     writeln;
   end;
 end.