P3163 [CQOI2014] 危桥

题意

一张 \(n\) 个点的无相图，有些边只能走两次，问能否在 \(a_1\)，\(a_2\) 之间往返 \(a_n\) 次，在 \(b_1\)，\(b_2\) 之间往返 \(b_n\) 次。
\(n\le50\)。

思路

先跑一遍最大流，然后交换 \(b1,b2\)，再跑一边最大流。如果两遍都满流了，那么可行，否则不可行。
看起来非常神奇，来思考一下为什么是对的。跑一边最大流不行有两个原因：\(b\) 有流量流到 \(a\) 和只能走两次的边正反都走了。
假设在第一遍最大流中，\(a_1\) 有 \(x\) 流量流到 \(b_2\)，并从那里流走，那么也有 \(x\) 的流量从 \(b_1\) 流到 \(a_2\)，并从那里流走了。在第二次最大流中，由于能流满，所以 \(a_1\) 有 \(x\) 流量流到 \(b_1\)，\(b_2\) 有 \(x\) 流量流到 \(a_2\)。把图画出来，张这个样：

由于有限制的边容量都是 \(2\)，所以 \(x\) 是偶数。那么让从路径 \(a_1\rightarrow b_2\rightarrow a_2\) 的路径流 \(\frac x2\)。路径 \(a_1\rightarrow b_1\rightarrow a_2\) 流 \(\frac x2\)，路径 \(b_1\rightarrow a_1\rightarrow b_2\) 流 \(\frac x2\)，路径 \(b_1\rightarrow a_2\rightarrow b_2\) 流 \(\frac x2\) 即可构造一组合法的方案。
那么第一个原因解决了，来思考第二个原因。感性理解，把 \(b_1,b_2\) 交换，经过的边就反向，如果一条有限制的边在第一遍最大流中正反都流了，那么反向后就爆了，所以不可能出现这种情况。

代码

// Problem: P3163 [CQOI2014] 危桥
// Contest: Luogu
// URL: https://www.luogu.com.cn/problem/P3163
// Memory Limit: 125 MB
// Time Limit: 1000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
using namespace std;
namespace IO{
    template<typename T>
    inline void read(T&x){
        x=0;char c=getchar();bool f=0;
        while(!isdigit(c)) c=='-'?f=1:0,c=getchar();
        while(isdigit(c)) x=x*10+c-'0',c=getchar();
        f?x=-x:0;
    }
    template<typename T>
    inline void write(T x){
        if(x==0){putchar('0');return ;}
        x<0?x=-x,putchar('-'):0;short st[50],top=0;
        while(x) st[++top]=x%10,x/=10;
        while(top) putchar(st[top--]+'0');
    }
    inline void read(char&c){c=getchar();while(isspace(c)) c=getchar();}
    inline void write(char c){putchar(c);}
    inline void read(string&s){s.clear();char c;read(c);while(!isspace(c)&&~c) s+=c,c=getchar();}
    inline void write(string s){for(int i=0,len=s.size();i<len;i++) putchar(s[i]);}
    template<typename T>inline void write(T*x){while(*x) putchar(*(x++));}
    template<typename T,typename...T2> inline void read(T&x,T2&...y){read(x),read(y...);}
    template<typename T,typename...T2> inline void write(const T x,const T2...y){write(x),putchar(' '),write(y...),sizeof...(y)==1?putchar('\n'):0;}
}using namespace IO;
const int maxn=100,inf=1000000000;
int N,a1,a2,an,b1,b2,bn,bh[maxn][maxn];
char a[maxn][maxn];
template<int maxn,int maxm>class LSQXX{
public:
    int head[maxn],nxt[maxm*2],to[maxm*2],val[maxm*2],cnt=1;
    void add(int u,int v,int w){nxt[++cnt]=head[u],to[cnt]=v,val[cnt]=w,head[u]=cnt;}
    void clear(){memset(head,0,sizeof(head)),cnt=1;}
};
class Network_Flow{
private:
    LSQXX<maxn,maxn*maxn>e;
    int s,t,d[maxn],cur[maxn];
    void edge_add(int u,int v,int w){e.add(u,v,w),e.add(v,u,0);}
    bool bfs(){
        for(int i=s;i<=t;i++) d[i]=inf;
        queue<int>q;q.push(s);d[s]=0;
        while(!q.empty()){
            int u=q.front();q.pop();
            for(int i=e.head[u];i;i=e.nxt[i]){
                int v=e.to[i];
                if(e.val[i]==0) continue;
                if(d[v]>d[u]+1) d[v]=d[u]+1,q.push(v);
            }
        }
        return d[t]!=inf;
    }
    int dfs(int u,int flow=inf){
        if(flow==0) return 0;
        if(u==t) return flow;
        int ans=0;
        for(int&i=cur[u];i;i=e.nxt[i]){
            int v=e.to[i];
            if(d[v]!=d[u]+1) continue;
            if(e.val[i]==0) continue;
            int new_flow=dfs(v,min(flow,e.val[i]));
            flow-=new_flow,ans+=new_flow;
            e.val[i]-=new_flow,e.val[i^1]+=new_flow;
            if(flow==0) return ans;
        }
        return ans;
    }
public:
    void build(){
        e.clear();
        s=0,t=N+1;
        for(int i=1;i<=N;i++) for(int j=1;j<=N;j++){
            if(a[i][j]=='O') edge_add(i,j,1);
            if(a[i][j]=='N') edge_add(i,j,inf);
        }
        edge_add(s,a1,an),edge_add(s,b1,bn);
        edge_add(a2,t,an),edge_add(b2,t,bn);
    }
    int work(){
        int ans=0;
        while(bfs()){
            for(int i=s;i<=t;i++) cur[i]=e.head[i];
            ans+=dfs(s);
        }
        return ans;
    }
}wll;
void solve(){
    a1++,a2++,b1++,b2++;
    for(int i=1;i<=N;i++) for(int j=1;j<=N;j++) read(a[i][j]);
    wll.build();
    int flow1=wll.work();
    swap(b1,b2);
    wll.build();
    int flow2=wll.work();
    if(flow1==an+bn&&flow2==an+bn) write("Yes\n");
    else write("No\n");
}
signed main(){
    while(scanf("%d%d%d%d%d%d%d",&N,&a1,&a2,&an,&b1,&b2,&bn)!=EOF) solve();
    return 0;
}