网络流24题（01）搭配飞行员（最大流）

思路：

设置源点为 0，汇点为 n + 1，源点向飞行员引弧，容量为 1，飞行员和副飞行员引弧，容量为 1，副飞行员向 汇点引弧，容量为 1，求最大流。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;

const int MAXN = 110;
const int INFS = 0x3FFFFFFF;

struct edge {
    int from, to, cap, flow;
    edge(int _from, int _to, int _cap, int _flow) 
        : from(_from), to(_to), cap(_cap), flow(_flow) {}
};

struct ISAP {
    vector<edge> edges;
    vector<int> G[MAXN];
    int s, t, n;
    int d[MAXN], p[MAXN], cur[MAXN], gap[MAXN];
    bool vis[MAXN];

    void clearall(int n) {
        this->n = n;
        edges.clear();
        for (int i = 0; i < n; i++)
            G[i].clear();
    }

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

    bool BFS() {
        queue<int> Q;
        memset(d, 0, sizeof(d));
        memset(vis, false, sizeof(vis));
        vis[t] = true;
        Q.push(t);

        while (!Q.empty()) {
            int x = Q.front(); Q.pop();
            for (int i = 0; i < G[x].size(); i++) {
                edge& e = edges[G[x][i]^1];
                if (e.cap > e.flow && !vis[e.from]) {
                    vis[e.from] = true;
                    d[e.from] = d[x] + 1;
                    Q.push(e.from);
                }
            }
        }
        return vis[s];
    }

    int augment() {
        int x = t, f = INFS;
        while (x != s) {
            edge& e = edges[p[x]];
            f = min(f, e.cap - e.flow);
            x = e.from;
        }
        x = t;
        while (x != s) {
            edges[p[x]].flow += f;
            edges[p[x]^1].flow -= f;
            x = edges[p[x]].from;
        }
        return f;
    }

    int maxflow(int s, int t) {
        this->s = s, this->t = t;
        BFS();
        memset(cur, 0, sizeof(cur));
        memset(p, 0, sizeof(p));
        memset(gap, 0, sizeof(gap));
        for (int i = 0; i < n; i++)
            gap[d[i]] += 1;
        int x = s, flow = 0;
        while (gap[s] < n) {
            if (x == t) {
                flow += augment();
                x = s;
            }
            bool flag = false;
            for (int i = cur[x]; i < G[x].size(); i++) {
                edge& e = edges[G[x][i]];
                if (d[x] == d[e.to] + 1 && e.cap > e.flow) {
                    flag = true;
                    cur[x] = i;
                    p[e.to] = G[x][i];
                    x = e.to; break;
                }
            }
            if (!flag) {
                int m = n - 1;
                for (int i = 0; i < G[x].size(); i++) {
                    edge& e = edges[G[x][i]];
                    if (e.cap > e.flow) m = min(m, d[e.to]);
                }
                if (--gap[d[x]] == 0) break;
                gap[d[x] = m+1] += 1;
                cur[x] = 0;
                if (x != s) x = edges[p[x]].from;
            }
        }
        return flow;
    }
};

ISAP sap;

int main() {
    freopen("flyer.in", "r", stdin);
    freopen("flyer.out", "w", stdout);

    int n, n1;
    scanf("%d%d", &n, &n1);
    int u, v;
    sap.clearall(n + 2);
    while (scanf("%d%d", &u, &v) != EOF) {
        sap.addedge(u, v, 1);
    }

    int s = 0, t = n + 1;
    for (int i = 1; i <= n1; i++)
        sap.addedge(s, i, 1);
    for (int i = n1+1; i <= n; i++)
        sap.addedge(i, t, 1);

    printf("%d\n", sap.maxflow(s, t));
    return 0;
}