bzoj3504 [Cqoi2014]危桥

无向图最大流，加上超级源汇，以及神奇的判断

在处理a1的流会走到b2的情况时卡住了，果断看题解发现把b1和b2反一下再做一次最大流就行了（这是为什么呢，没看见证明= =）

先放在这里，等我想下再补充证明

4天后才补充证明= =!

如果不存在合题的最大流，即会出现交叉的流（a1流向b2的情况），不过我们在实现时一定不会出现b1只流向b2，而a1有多余流量流向b2的情况，因为我们总是令S到b1 和b2到T 的流量是相等的（S，T为超级源和超级汇），换句话说交叉流只会是a1全部流向b2，b1全部流向a2的情况，即a1可能不与a2连通而与b2连通，b1也与a2连通不与b2连通，此时只需b1和b2互换，再做一次最大流，来检查是否连通，如果依然满流（即连通），则存在合题的流，否则不存在。

#include<bits/stdc++.h>
using namespace std;

struct edge {
    int u, v, cap;
};

const int MAXN = 50;
const int INF = 0xffff;

struct MaxFlow  {
    int n, m;

    vector<edge> Edge;
    vector<int> G[MAXN + 10];

    int a1, a2, an, b1, b2, bn;
    int maze[MAXN + 10][MAXN + 10];

    void init() {
        Edge.clear();
        for(int i = 1; i <= n; i++)
            G[i].clear();
    }

    void Addedge(int u, int v, int cap)  {
        Edge.push_back((edge){u, v, cap});
        Edge.push_back((edge){v, u, 0});
        G[u].push_back(Edge.size() - 2);
        G[v].push_back(Edge.size() - 1);
    }

    void build()    {
        S = n, T = n - 1;
        init();
        int u, v;
        for(u = 1; u <= n; u++) for(v = 1; v <= n; v++) {
            if(maze[u][v] == 1) Addedge(u, v, 2);
            if(maze[u][v] == 2) Addedge(u, v, INF);
        }
    }

    int S, T;
    int d[MAXN + 10], vd[MAXN + 10];

    int aug(int u, int augco)   {
        if(u == T)  return augco;

        int augc = augco, min_d = n - 1;
        for(int i = 0; i < G[u].size(); i++)    {
            edge &e = Edge[G[u][i]], &r = Edge[G[u][i] ^ 1];
            if(e.cap > 0)   {
                if(d[e.u] == d[e.v] + 1)    {
                    int tmp = min(augc, e.cap);
                    tmp = aug(e.v, tmp);
                    e.cap -= tmp;   r.cap += tmp;
                    augc -= tmp;
                    if(d[S] >= n)   return augco - augc;
                    if(augc == 0)   break;
                }
                min_d = min(min_d, d[e.v]);
            }
        }
        if(augco == augc)   {
            vd[d[u]]--;
            if(vd[d[u]] == 0)   d[S] = n;
            d[u] = min_d + 1;
            vd[d[u]]++;
        }
        return augco - augc;
    }

    int ISAP()  {
        memset(d, 0, sizeof(d));
        memset(vd, 0, sizeof(vd));
        vd[0] = n;
        int flow = 0;
        while(d[S] < n)
            flow += aug(S, INF);
        return flow;
    }

    void work() {
        bool flag = 1;
        build();
        Addedge(S, a1, an); Addedge(a2, T, an);
        Addedge(S, b1, bn); Addedge(b2, T, bn);
        if(ISAP() < an + bn)  flag = 0;
        if(flag)    {
            build();
            Addedge(S, a1, an); Addedge(a2, T, an);
            Addedge(S, b2, bn); Addedge(b1, T, bn);
            if(ISAP() < an + bn)  flag = 0;
        }
        if(flag)    puts("Yes");
        else puts("No");
    }

    bool Read() {
        int i, j;
        char s[60];

        if(scanf("%d", &n) != 1)    return 0;
        memset(maze, 0, sizeof(maze));

        scanf("%d%d%d", &a1, &a2, &an);
        scanf("%d%d%d", &b1, &b2, &bn);
        a1++, a2++, b1++, b2++;
        an *= 2;    bn *= 2;

        for(i = 1; i <= n; i++)  {
            scanf("%s", s + 1);
            for(j = 1; j <= n; j++) {
                if(s[j] == 'O') maze[i][j] = 1;
                if(s[j] == 'N') maze[i][j] = 2;
            }
        }

        n += 2;
        return 1;
    }

}   sp;

int main()  {
    while(sp.Read())
        sp.work();
    return 0;
}