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=2000000007;
type node=record
       next,point,flow,cost:longint;
     end;

var edge:array[0..2000010] of node;
    q:array[0..1000010] of longint;
    s,p,cur,pre,d:array[0..10010] of longint;
    v:array[0..10010] of boolean;
    a:array[0..110,0..110] 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:=1;
    r:=1;
    q[1]:=0;
    fillchar(v,sizeof(v),false);
    v[0]:=true;
    for i:=1 to t do
      d[i]:=inf;
    d[0]:=0;
    while f<=r do
    begin
      x:=q[f];
      v[x]:=false;
      i:=p[x];
      while i<>-1 do
      begin
        y:=edge[i].point;
        if edge[i].flow>0 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:=0;
    while spfa do
    begin
      i:=t;
      mincost:=mincost+d[t];
      while i<>0 do
      begin
        j:=cur[i];
        dec(edge[j].flow);
        inc(edge[j xor 1].flow);
        i:=pre[i];
      end;
    end;
  end;

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

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

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