bzoj3504

这是一道最大流的题目
首先要引起注意的是，这类多个起点多个终点的问题一定要同时跑，不能分开来跑
由于是无向图，也就相当于从起点跑2*n次
好，不难想到s向两个起点连边，两终点想t连边，流量为2*an或2*bn
然后对于每条危桥，正向反向连边，流量都为2，然后做最大流判断是否满流
但是这样会出现两个问题，第一个如下的情况
6 0 1 1 3 2 1
XXXXOX
XXXXXO
XXXXOX
XXXXXO
OXOXXO
XOXOOX
不难发现中间有条边正向反向都被经过两次，而实际上是不允许的
第二种情况时会出现a1只能b2,b1只能流向a2，这样做应该是不可行的，但实际会产生可行解
解决的办法很简单，我们只要把b1,b2位置换一下，重新构图，再做一次最大流即可
首先对于情况一，如果b1到b2必须多次经过某条边若干次，并且与a1到a2经过这条边反向
那我们把b1b2调换后，就变成了经过双方都是同向经过，这样就只受到了一个流量限制
而对于情况二，正确性是显然的
于是我们就解决了这个问题

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

var edge:array[0..200010] of node;
    a:array[0..51,0..51] of longint;
    pre,p,numh,cur,h,d:array[0..110] of longint;
    i,j,t,a1,a2,an,b1,b2,bn,n,len:longint;
    ch:char;

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 neck,u,i,j,tmp,q:longint;
  begin
    fillchar(h,sizeof(h),0);
    fillchar(numh,sizeof(numh),0);
    numh[0]:=t+1;
    for i:=0 to t do
      cur[i]:=p[i];
    u:=0;
    sap:=0;
    neck:=inf;
    while h[0]<t+1 do
    begin
     { writeln(u);
      readln;     }
      d[u]:=neck;
      i:=cur[u];
      while i<>-1 do
      begin
        j:=edge[i].point;
        if (edge[i].flow>0) and (h[u]=h[j]+1) then
        begin
          pre[j]:=u;
          cur[u]:=i;
          u:=j;
          neck:=min(edge[i].flow,neck);
          if u=t then
          begin
            sap:=sap+neck;
            while u<>0 do
            begin
              u:=pre[u];
              j:=cur[u];
              dec(edge[j].flow,neck);
              inc(edge[j xor 1].flow,neck);
            end;
            neck:=inf;
          end;
          break;
        end;
        i:=edge[i].next;
      end;
      if i=-1 then
      begin
        dec(numh[h[u]]);
        if numh[h[u]]=0 then exit;
        q:=-1;
        tmp:=t;
        i:=p[u];
        while i<>-1 do
        begin
          j:=edge[i].point;
          if edge[i].flow>0 then
            if h[j]<tmp then
            begin
              tmp:=h[j];
              q:=i;
            end;
          i:=edge[i].next;
        end;
        cur[u]:=q;
        h[u]:=tmp+1;
        inc(numh[h[u]]);
        if u<>0 then
        begin
          u:=pre[u];
          neck:=d[u];
        end;
      end;
    end;
  end;

procedure work(x,y,f:longint);
  begin
    add(x,y,f);
    add(y,x,0);
  end;

procedure build;
  var i,j:longint;
  begin
    fillchar(p,sizeof(p),255);
    len:=-1;
    for i:=1 to n do
      for j:=1 to n do
        if a[i,j]<>0 then work(i,j,a[i,j]);
  end;

begin
  while not eof do
  begin
    readln(n,a1,a2,an,b1,b2,bn);
    inc(a1);
    inc(a2);
    inc(b1);
    inc(b2);
    fillchar(a,sizeof(a),0);
    t:=n+1;
    for i:=1 to n do
    begin
      for j:=1 to n do
      begin
        read(ch);
        if ch='O' then a[i,j]:=2
        else if ch='N' then a[i,j]:=inf;
      end;
      readln;
    end;
    build;
    work(0,a1,2*an);
    work(a2,t,2*an);
    work(0,b2,2*bn);
    work(b1,t,2*bn);
    if sap=2*(an+bn) then
    begin
      build;
      work(0,a1,2*an);
      work(a2,t,2*an);
      work(0,b1,2*bn);
      work(b2,t,2*bn);
      if sap=2*(an+bn) then writeln('Yes')
      else writeln('No');
    end
    else writeln('No');
  end;
end.