【POJ2699】The Maximum Number of Strong Kings（二分，最大流）

题意：

有n个队伍，两两都有比赛

知道最后每支队伍获胜的场数

求最多有多少队伍，他们战胜了所有获胜场数比自己多的队伍，这些队伍被称为SK

N<=50

思路：把每个队伍和它们两两之间的比赛都当做点，判断最大流是否满流即可

S——>队伍 a[i]

队伍 ——>比赛 1

比赛——>T 1

i号队伍是SK：如果j为SK且a[i]>a[j]则j必胜，如果a[i]<a[j]则i必胜 只要必胜者向他们之间的比赛连1条边即可

                   如果j不为SK，胜负未知，两个点都向他们之间的比赛连1条边

i号队伍不是SK：对于所有的队伍都胜负未知，同上处理

最暴力的思想就是枚举每个队伍作为SK的可能性再根据得分情况连边，其实也能过

不过可以证明一定存在一种方案，使得SK是排序后得分最多的那些队伍

二分或枚举答案即可

证明见http://blog.csdn.net/sdj222555/article/details/7797257

var head,a:array[1..300]of longint;
    fan:array[1..200000]of longint;
    vet,next,len,dis,gap,flag:array[0..20000]of longint;
    num:array[1..100,1..100]of longint;
    n,i,j,tot,l,r,mid,last,s,source,src,cas,v,k:longint;
    ch:ansistring;

function min(x,y:longint):longint;
begin
 if x<y then exit(x);
 exit(y);
end;

procedure add(a,b,c:longint);
begin

 inc(tot);
 next[tot]:=head[a];
 vet[tot]:=b;
 len[tot]:=c;
 head[a]:=tot;

 inc(tot);
 next[tot]:=head[b];
 vet[tot]:=a;
 len[tot]:=0;
 head[b]:=tot;

end;

procedure swap(var x,y:longint);
var t:longint;
begin
 t:=x; x:=y; y:=t;
end;

procedure qsort(l,r:longint);
var i,j,mid:longint;
begin
 i:=l; j:=r; mid:=a[(l+r)>>1];
 repeat
  while mid<a[i] do inc(i);
  while mid>a[j] do dec(j);
  if i<=j then
  begin
   swap(a[i],a[j]);
   inc(i); dec(j);
  end;
 until i>j;
 if l<j then qsort(l,j);
 if i<r then qsort(i,r);
end;

function dfs(u,aug:longint):longint;
var e,v,t,val,flow:longint;
begin
 if u=src then exit(aug);
 e:=head[u]; val:=s-1; flow:=0;
 while e<>0 do
 begin
  v:=vet[e];
  if len[e]>0 then
  begin
   if dis[u]=dis[v]+1 then
   begin
    t:=dfs(v,min(len[e],aug-flow));
    len[e]:=len[e]-t;
    len[fan[e]]:=len[fan[e]]+t;
    flow:=flow+t;
    if dis[source]>=s then exit(flow);
    if aug=flow then break;
   end;
   val:=min(val,dis[v]);
  end;
  e:=next[e];
 end;
 if flow=0 then
 begin
  dec(gap[dis[u]]);
  if gap[dis[u]]=0 then dis[source]:=s;
  dis[u]:=val+1;
  inc(gap[dis[u]]);
 end;
 exit(flow);
end;

function maxflow:longint;
var ans:longint;
begin
 fillchar(gap,sizeof(gap),0);
 fillchar(dis,sizeof(dis),0);
 gap[0]:=s; ans:=0;
 while dis[source]<s do ans:=ans+dfs(source,maxlongint);
 exit(ans);
end;

procedure build(k:longint);
var i,j:longint;
begin
 fillchar(flag,sizeof(flag),0);
 fillchar(head,sizeof(head),0); tot:=0;

 for i:=1 to k do
 begin
  for j:=1 to i-1 do
  begin
   flag[num[i,j]]:=1;
   add(i,num[i,j],1);
  end;
  for j:=i+1 to n do
   if (a[j]<a[i])and(j<=k)and(flag[num[i,j]]=0) then
   begin
    flag[num[i,j]]:=1;
    add(j,num[i,j],1);
   end
    else if flag[num[i,j]]=0 then
    begin
     flag[num[i,j]]:=1;
     add(i,num[i,j],1);
     add(j,num[i,j],1);
    end;
 end;
 for i:=k+1 to n do
  for j:=1 to n do
   if (i<>j)and(flag[num[i,j]]=0) then
   begin
    add(i,num[i,j],1);
    add(j,num[i,j],1);
    flag[num[i,j]]:=1;
   end;
 for i:=1 to n do add(source,i,a[i]);
 for i:=1 to n do
  for j:=1 to n do
   if i<j then add(num[i,j],src,1);
end;

function isok(k:longint):boolean;
begin
 if maxflow=n*(n-1) div 2 then exit(true);
 exit(false);
end;

begin
 assign(input,'poj2699.in'); reset(input);
 assign(output,'poj2699.out'); rewrite(output);
 for i:=1 to 200000 do
  if i mod 2=1 then fan[i]:=i+1
   else fan[i]:=i-1;
 readln(cas);
 for v:=1 to cas do
 begin
  fillchar(num,sizeof(num),0);
  readln(ch); k:=length(ch);
  fillchar(a,sizeof(a),0); n:=0;
  i:=0;
  while i<k do
  begin
   inc(i);
   while (i<k)and(ch[i]=' ') do inc(i);
   inc(n);
   while (i<=k)and(ch[i]<>' ') do
   begin
    a[n]:=a[n]*10+ord(ch[i])-ord('0');
    inc(i);
   end;
  end;

  qsort(1,n); s:=n;
  for i:=1 to n do
   for j:=1 to n do
    if i<>j then
    begin
     if num[j,i]=0 then
     begin
      inc(s); num[i,j]:=s;
     end
      else num[i,j]:=num[j,i];
    end;
  inc(s); source:=s; inc(s); src:=s;

  l:=0; r:=n; last:=0;
  while l<=r do
  begin
   mid:=(l+r)>>1;
   build(mid);
   if isok(mid) then begin last:=mid; l:=mid+1; end
    else r:=mid-1;
  end;
  writeln(last);
 end;
 close(input);
 close(output);
end.