bzoj3504 [Cqoi2014]危桥

题目链接：bzoj3504
题目大意：
Alice和Bob居住在一个由N座岛屿组成的国家，岛屿被编号为0到N-1。某些岛屿之间有桥相连，桥上的道路是双向的，但一次只能供一人通行。其中一些桥由于年久失修成为危桥，最多只能通行两次。Alice希望在岛屿al和a2之间往返an次（从al到a2再从a2到al算一次往返）。同时，Bob希望在岛屿bl和b2之间往返bn次。这个过程中，所有危桥最多通行两次，其余的桥可以无限次通行。请问Alice和Bob能完成他们的愿望吗？

题解：
最大流
啊往返，又是无向边，那么对于危桥的话一个方向最多只能走一次。
一开始在想是应该分开走跑残图还是一起走。
发现两种都不可以QwQ
处理往返什么的还想着拆点一个出一个入QwQ
too naive
直接按原图建边
设个超级源点和超级汇点
超级源点向起始位置连个流量为往返次数的边，终止位置向超级汇点连个流量为往返次数的边。两个人一起走。判是否满流。
当然，这是会有问题。
但是，大家都说把其中一个人的起点和终点反过来再建图跑一次也判是否满流就可以了。。。

来自http://www.cnblogs.com/zhonghaoxi/p/3294465.html 的证明

第一次未交换时，我们假设流出来的方案是又不合法的，那么我们设从a1流到b2的流量为x那么有：
a1到a2的流量=an-x
a1到b2的流量=x
b1到a2的流量=x
b1到b2的流量=bn-x
第二次我们交换b1，b2，那么由于都是无向边，那么首先b2从b1可以流bn-x的流量，a1到a2仍然可以流an-x的流量，也就是说两边都还差x的流量。由于第二次流出来是满流的，那么如果我们最后流出来的方案是a1给b1流了x的流量导致满流，那么我们有：
a1到b1和b2都可以流x的流量，那么再交换之后，从a1流到b1的流量我们可以调整为先从b2流到了a1，再从a1流到了b1总共x的流量（关键之处是在于无向图），那么另外一边也可以对称的调整，所以一旦满流，就一定存在可行解。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;
#define maxn 110

const int inf=0x7fffffff;
struct node
{
    int y,c,next,ot;
}a[maxn*maxn*4];int len,first[maxn];
void ins(int x,int y,int c)
{
    len++;int n1=len;a[len].y=y;a[len].c=c;
    a[len].next=first[x];first[x]=len;
    len++;int n2=len;a[len].y=x;a[len].c=0;
    a[len].next=first[y];first[y]=len;
    a[n1].ot=n2;a[n2].ot=n1;
}
queue<int> q;char s[maxn];
int S,T,d[maxn];bool vis[maxn];
int mymin(int x,int y){return (x<y)?x:y;}
bool bfs()
{
    for (int i=1;i<=T;i++) d[i]=-1;
    d[S]=0;vis[S]=true;q.push(S);
    while (!q.empty())
    {
        int x=q.front();q.pop();
        for (int k=first[x];k!=-1;k=a[k].next)
        {
            int y=a[k].y;
            if (a[k].c<=0) continue;
            if (d[y]==-1)
            {
                d[y]=d[x]+1;
                if (!vis[y])
                {
                    vis[y]=true;
                    q.push(y);
                }
            }
        }vis[x]=false;
    }
    return d[T]!=-1;
}
int dfs(int x,int flow)
{
    if (x==T) return flow;
    int delta=0;
    for (int k=first[x];k!=-1;k=a[k].next)
    {
        int y=a[k].y;
        if (a[k].c<=0) continue;
        if (d[y]==d[x]+1)
        {
            int minf=mymin(flow-delta,a[k].c);
            minf=dfs(y,minf);
            a[k].c-=minf;
            a[a[k].ot].c+=minf;
            delta+=minf;
            if (delta==flow) break;
        }
    }if (delta==0) d[x]=-1;
    return delta;
}
int dinic()
{
    int ret=0;
    while (bfs()) ret+=dfs(S,inf);
    return ret;
}
int n,v[110][110];
void maki(int a1,int a2,int an,int b1,int b2,int bn)
{
    len=0;memset(first,-1,sizeof(first));
    for (int i=1;i<=n;i++)
     for (int j=1;j<=n;j++)
      if (v[i][j])
        ins(i,j,v[i][j]);
    ins(S,a1,an);ins(a2,T,an);
    ins(S,b1,bn);ins(b2,T,bn);
}
int main()
{
    //freopen("a.in","r",stdin);
    //freopen("a.out","w",stdout);
    int a1,a2,an,b1,b2,bn,i,j;
    while (scanf("%d%d%d%d%d%d%d\n",&n,&a1,&a2,&an,&b1,&b2,&bn)!=EOF)
    {
        a1++;a2++;b1++;b2++;
        S=n+1;T=S+1;
        for (i=1;i<=n;i++)
        {
            gets(s+1);
            for (j=1;j<=n;j++) 
             if (s[j]!='X')
             {
                if (s[j]=='O') v[i][j]=1;
                else v[i][j]=inf;
             }else v[i][j]=0;
        }
        bool flag=true;
        maki(a1,a2,an,b1,b2,bn);
        int f1=dinic();
        if (f1!=an+bn) flag=false;
        if (flag)
        {
            maki(a1,a2,an,b2,b1,bn);
            f1=dinic();
            if (f1!=an+bn) flag=false;
        }
        if (flag) printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}