bzoj 2140: 稳定婚姻 （二分图）

//==========================

蒟蒻Macaulish：http://www.cnblogs.com/Macaulish/  转载要声明！

//==========================

判断二分图中某条路是否是唯一的。

网络流做法要加个tarjan

二分图就是再增广看能不能增广

网络流（快但是长）

type
  arr=record
    toward,next,cap,from:longint;
  end;
const
  maxn=;
  maxm=;
var
  edge:array[..maxm]of arr;
  first,cur,d,p,gap,num,e,belong,dfn,low:array[..maxn]of longint;
  chose:array[..maxn]of boolean;
  trie:array[..maxn,'A'..'z'] of longint;
  n,esum,s,t,tot,total,peo,time,scc,top:longint;

procedure add(j,k,l:longint);
begin
  inc(esum);
  edge[esum].toward:=k;
  edge[esum].next:=first[j];
  first[j]:=esum;
  edge[esum].from:=j;
  edge[esum].cap:=l;
end;

procedure addedge(j,k,l:longint);
begin
  add(j,k,l);
  add(k,j,);
end;

function find(ss:string):longint;
var
  i,u:longint;
begin
  u:=;
  for i:= to length(ss) do u:=trie[u][ss[i]];
  exit(num[u]);
end;

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

procedure into;
var
  i,j,k,m,u,boy,girl:longint;
  ss:string;
begin
  esum:=-;
  tot:=;
  total:=;
  peo:=;
  fillchar(first,sizeof(first),);
  readln(n);
  s:=n<<+;
  t:=n<<+;
  tot:=n<<+;
  for i:= to n do begin

    readln(ss);
    ss:=ss+' ';
    u:=;
    j:=;
    while (ss[j]<>' ') do begin
      if trie[u][ss[j]]= then begin
        inc(total);
        trie[u][ss[j]]:=total;
      end;
      u:=trie[u][ss[j]];
      inc(j);
    end;
    inc(peo);
    num[u]:=peo;
    girl:=peo;

    inc(j);
    u:=;
    while (ss[j]<>' ') do begin
      if trie[u][ss[j]]= then begin
        inc(total);
        trie[u][ss[j]]:=total;
      end;
      u:=trie[u][ss[j]];
      inc(j);
    end;
    inc(peo);
    num[u]:=peo;
    boy:=peo;

    e[i]:=esum+;
    addedge(girl,boy,);
    addedge(s,girl,);
    addedge(boy,t,);

  end;
  readln(m);
  while m> do begin
    dec(m);
    readln(ss);
    i:=pos(' ',ss);
    j:=find(copy(ss,,i-));
    k:=find(copy(ss,i+,length(ss)-i));
    addedge(j,k,);
  end;
end;

function sap(x,flow:longint):longint;
var
  now,more,i,too:longint;
begin
  if x=t then exit(flow);
  now:=;
  i:=cur[x];
  while i>= do begin
    too:=edge[i].toward;
    if (d[x]=d[too]+) and (edge[i].cap>) then begin
      more:=sap(too,min(flow-now,edge[i].cap));
      dec(edge[i].cap,more);
      inc(edge[i xor ].cap,more);
      inc(now,more);
      cur[x]:=i;
      if flow=now then exit(flow);
    end;
    i:=edge[i].next;
  end;
  dec(gap[d[x]]);
  if gap[d[x]]= then d[s]:=tot;
  inc(d[x]);
  inc(gap[d[x]]);
  cur[x]:=first[x];
  exit(now);
end;

procedure maxflow;
var
  i:longint;
begin
  fillchar(gap,sizeof(gap),);
  fillchar(d,sizeof(d),);
  gap[]:=tot;
  for i:= to tot do cur[i]:=first[i];
  while d[s]<tot do sap(s,maxlongint);
end;

procedure tarjan(x:longint);
var
  i,j,too:longint;
begin
  inc(time);
  dfn[x]:=time;
  low[x]:=time;
  inc(top);
  p[top]:=x;
  chose[x]:=true;
  i:=first[x];
  while i>= do begin
    if edge[i].cap> then begin
      too:=edge[i].toward;
      if dfn[too]= then begin
        tarjan(too);
        low[x]:=min(low[x],low[too]);
      end
      else
        if chose[too] then
          low[x]:=min(low[x],low[too]);
    end;
    i:=edge[i].next;
  end;
  if low[x]=dfn[x] then begin
    inc(scc);
    repeat
      j:=p[top];
      dec(top);
      chose[j]:=false;
      belong[j]:=scc;
    until j=x;
  end;
end;

procedure work;
var
  head,tail,i,j,k,l,x,too:longint;
  flag:boolean;
begin
  time:=;
  fillchar(chose,sizeof(chose),false);
  fillchar(dfn,sizeof(dfn),);
  top:=;
  for i:= to tot do
    if dfn[i]= then tarjan(i);
  for i:= to n do begin
    j:=e[i];
    k:=edge[j].from;
    l:=edge[j].toward;
    if (belong[k]=belong[l]) or (edge[j].cap>) then writeln('Unsafe')
      else  writeln('Safe');
  end;
end;

begin
  into;
  maxflow;
  work;
end.

匈牙利版

type
  arr=record
    toward,next,from:longint;
    flag:boolean;
  end;
const
  maxn=;
  maxm=;
var
  edge:array[..maxm]of arr;
  first,cur,d,p,gap,num,e,match,matche:array[..maxn]of longint;
  chose:array[..maxn]of boolean;
  trie:array[..maxn,'A'..'z'] of longint;
  n,esum,s,t,tot,total,peo,time,scc,top:longint;

procedure addedge(j,k:longint);
begin
  inc(esum);
  edge[esum].from:=j;
  edge[esum].toward:=k;
  edge[esum].next:=first[j];
  edge[esum].flag:=true;
  first[j]:=esum;
end;

function find(ss:string):longint;
var
  i,u:longint;
begin
  u:=;
  for i:= to length(ss) do u:=trie[u][ss[i]];
  exit(num[u]);
end;

procedure into;
var
  i,j,k,m,u,boy,girl:longint;
  ss:string;
begin
  esum:=;
  tot:=;
  total:=;
  peo:=;
  fillchar(first,sizeof(first),);
  readln(n);
  for i:= to n do begin

    readln(ss);
    ss:=ss+' ';
    u:=;
    j:=;
    while (ss[j]<>' ') do begin
      if trie[u][ss[j]]= then begin
        inc(total);
        trie[u][ss[j]]:=total;
      end;
      u:=trie[u][ss[j]];
      inc(j);
    end;
    inc(peo);
    num[u]:=peo;
    girl:=peo;

    inc(j);
    u:=;
    while (ss[j]<>' ') do begin
      if trie[u][ss[j]]= then begin
        inc(total);
        trie[u][ss[j]]:=total;
      end;
      u:=trie[u][ss[j]];
      inc(j);
    end;
    inc(peo);
    num[u]:=peo;
    boy:=peo;

    e[i]:=esum+;
    addedge(girl,boy);

  end;
  readln(m);
  while m> do begin
    dec(m);
    readln(ss);
    i:=pos(' ',ss);
    j:=find(copy(ss,,i-));
    k:=find(copy(ss,i+,length(ss)-i));
    addedge(j,k);
  end;
end;

function dfs(x:longint):boolean;
var
  i,too:longint;
begin
  i:=first[x];
  while i> do begin
    too:=edge[i].toward;
    if edge[i].flag and chose[too] then begin
      chose[too]:=false;
      if (match[too]=) or dfs(match[too]) then begin
        edge[matche[too]].flag:=true;
        matche[too]:=i;
        match[too]:=x;
        edge[i].flag:=false;
        exit(true);
      end;
    end;
    i:=edge[i].next;
  end;
  exit(false);
end;

procedure work;
var
  i,j,boy,girl:longint;
begin
  for i:= to n do begin
    fillchar(chose,sizeof(chose),true);
    dfs(edge[e[i]].from);
  end;
  //for i:= to n do writeln(match[i<<]);
  for i:= to n do begin
    fillchar(chose,sizeof(chose),true);
    j:=e[i];
    if edge[j].flag then begin
      writeln('Unsafe');
      continue;
    end;
    boy:=edge[j].toward;
    girl:=edge[j].from;
    match[boy]:=;
    if not dfs(girl) then begin
      match[boy]:=girl;
      matche[boy]:=j;
      writeln('Safe');
    end
      else writeln('Unsafe');
  end;
end;

begin
  into;
  work;
end.