A - 搭配飞行员 LibreOJ - 6000(最大流 或 二分图最大匹配)

题意

1. 总共用 n 个点，这个 n 个点可以被分割成两个集合中去，我们假设为 左集合 L、右集合 R，其中 L 中的元素只能与 R 中的某些元素进行匹配，问左集合 L 中的元素最大可以和 R 中的集合一对一形成的最大匹配数是多少？

思路

1. 因为这题中的点可以备份为两个集合，所以是让求的二分图最大匹配，如果不能被分成两个集合，那就要用 一般图的二分图最大匹配算法（带花树算法）了，
2. 二者这题我们只需要 跑一个二分图最大匹配就行了，
3. 或者建图跑网络流，
   1. 虚拟出一个 超级源点是 S 与 L 集合中的元素相连，流量为 1
   2. 虚拟出一个 超级汇点 T，把 R 集合的中的元素与 T 相连，流量为 1，
   3. R 与 L 之间的点若存在关系，那么就链接一条流量为 1 的边
   4. 最后跑网络流 dinic。

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <map>
#include <bitset>
#include <vector>
using namespace std;
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
void Run(int x = 0) {     
#ifdef ACM  //宏定义免注释 freopen
    if (! x) fre(); else Fre();
#endif
}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<ll, ll>
#define m_p make_pair
#define for_(i, s, e) for(ll i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(ll i = (ll)(e); i >= (ll)(s); i --)
#define memset(a, b, c) memset(a, (int)b, c);
#define size() size() * 1LL
#define sc scanf
#define pr printf
#define sd(a) sc("%lld", &a)
#define ss(a) sc("%s", a)
#define __  pr( "------------------------\n" );
#define ___ pr("\n------------------------\n");
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
/*=========================ACMer===========================*/
const int mxn = 2e4;
const int mxm = 1e5;
struct Edge
{
    int v, w, next;
} edge[mxm];
int head[mxn], tot;
void Add(int u, int v, int w)
{
    edge[++ tot] = (Edge){ v, w, head[u] }; head[u] = tot;
    edge[++ tot] = (Edge){ u, 0, head[v] }; head[v] = tot;
}

void init(int n)
{
    tot = 1;
    /* for_(i, 0, n) head[i] = 0; */
    memset(head, 0, sizeof head);
}

int n, m, s, t;
int lv[mxn], cur[mxn];        //分层、当前弧优化
queue<int> q;

bool bfs()
{
    /* for_(i, 0, t) lv[i] = -1, cur[i] = head[i]; */
    memset(lv, -1, sizeof lv);
    memcpy(cur, head, sizeof head);
    lv[s] = 0;
    q.push(s);
    while (q.size())
    {
        int u = q.front(); q.pop();
        for (int i = head[u]; i; i = edge[i].next)
        {
            int v = edge[i].v, w = edge[i].w;
            if (w > 0 && lv[v] == -1)
            {
                lv[v] = lv[u] + 1;
                q.push(v);
            }
        }
    }

    return lv[t] != -1;
}


int dfs(int u = s, int flow = inf)          //注意这里的返回的数据类型不能是 bool 哭。。。
{
    if (u == t) return flow;
    int rmn = flow;
    for (int i = cur[u]; i && rmn; i = edge[i].next)
    {
        cur[u] = i;
        int v = edge[i].v, w = edge[i].w;
        if (w > 0 && lv[v] == lv[u] + 1)
        {
            int c = dfs(v, min(w, rmn));
            rmn -= c;
            edge[i].w -= c;
            edge[i ^ 1].w += c;
        }
    }

    if (flow - rmn == 0) lv[u] = -inf;
    return flow - rmn;
}

int dinic()
{
    int ans = 0, c;
    while (bfs())
    {
        while ((c = dfs()) > 0) ans += c;
    }
    return ans;
}


int main()
{
    Run();
    int n, m;
    sc("%d %d", &n, &m);
    s = 0, t = n + 1;
    init(t);
    int u, v;
    while (sc("%d %d", &u, &v) != EOF)
    {
        Add(u, v, 1);
    }

    for_(i, 1, m)
    {
        Add(s, i, 1);
    }
    for_(i, m + 1, n)
    {
        Add(i, t, 1);
    }
    pr("%d", dinic());

    return 0;
}