图论进阶——二分图匹配（匈牙利+网络流算法）

前置知识

二分图染色

注意事项

首先，这张图需要是一个二分图

二分图匹配定义

在一个二分图内找出一些边，使得任何一个图中的点都被至多一条边连接，这些边的集合叫做一个二分图匹配。

如果存在一种二分图匹配方案，使得选出的边的数量最多，那么这就叫做二分图的最大匹配。

如果该二分图的最大匹配方案中，所有的顶点均被一条边所连接，那么这个方案就叫做二分图的一个完美匹配。

二分图匹配算法

$1.$匈牙利算法

引入：增广路

若P是图G中一条连通两个未匹配顶点的路径，并且属于M的边和不属于M的边(即已匹配和待匹配的边)在P上交替出现，则称P为相对于M的一条增广路径（举例来说，有A、B集合，增广路由A中一个点通向B中一个点，再由B中这个点通向A中一个点……交替进行）

再通俗一点说，增广路就是一个由$A-B-A-B-...$的顺序选择一些边的过程

原理：

如果在当前匹配方案下再也找不到增广路，那么当前匹配就是最大匹配。

很容易证明，因为如果找不到增广路，那么集合$A$到集合$B$就不可能再连一条边，我们所连的边数也不会增加。

如果存在增广路，那么我们一定可以有一种从$A$连到$B$的方案，那么我们的最大匹配就可以再增加。

流程：

$step1:$选择一个未被匹配过的点$u$。

$step2:$选出其一条没有走过的边，记该边另一端点为$v$，如果所有边全部被走过，则返回至$step1$。

$step3:$如果$v$已被染色，返回$step2$。

$step4:$此时$v$未被匹配，记录$v$的匹配点为$u$，答案$+1$，返回$step1$

Code

#include <bits/stdc++.h>
using namespace std;
int n, m, e, ans, match[1005];                 //match[i]为i的匹配点
bool a[1005][1005], vis[1005];      
bool dfs(int x){
    for (int i = 1; i <= m; i++)
        if (!vis[i] && a[x][i]){
            vis[i] = 1;
            if (!match[i] || dfs(match[i])){
                match[i] = x;
                return 1;
            }
        }
    return 0;
}
int main(){
    cin >> n >> m >> e;
    for (int i = 1; i <= e; i++){
        int u, v;
        scanf("%d%d", &u, &v);
        if (v <= m) a[u][v] = 1;
    }
    for (int i = 1; i <= n; i++){
        ans += dfs(i);
        memset(vis, 0, sizeof(vis));
    }
    cout << ans;
    return 0;
}

时间复杂度$O(nm)$
优点：短，好记忆
缺点：时间复杂度不优秀

$2.$网络流

强烈建议学之前看我的博客

由于我的博客里有提及网络流基础知识，故此处不再赘述。

先将该二分图染色，分成两个集合$A,B$

建立源点$s$，汇点$t$，$s$向$A$连容量为$1$的边，$B$向$t$连容量为$1$的边

对于每一条边，由$A$集合中的点向$B$集合中的点连容量为$1$的边

然后就可以跑我们的最大流了。

二分图最大匹配即为最大流。

由于所有二分图均可以用网络流做，且网络流用处更大，故推荐使用网络流。

时间复杂度$O(n\sqrt{m})$

Code

#include<bits/stdc++.h>
using namespace std;
int first[1000005],nxt[1000005],to[1000005],w[1000005],tot=1;
int n,m,e,s,t,dep[10005],cnt[10005];
int Read(){
    int x=0,f=1;
    char ch=getchar();
    while(!isdigit(ch)){
        if(ch=='-')  f=-1;
        ch=getchar();
    }
    while(isdigit(ch)){
        x=(x<<3)+(x<<1)+ch-'0';
        ch=getchar();
    }
    return x*f;
}
void Add(int x,int y,int z){
    nxt[++tot]=first[x];
    first[x]=tot;
    to[tot]=y;
    w[tot]=z;
}
void Bfs(int S){
    memset(dep,0xff,sizeof(dep));
    dep[S]=0;
    cnt[0]=1;
    queue<int> q;
    q.push(S);
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int e=first[u];e;e=nxt[e]){
            int v=to[e];
            if(dep[v]==-1){
                ++cnt[dep[v]=dep[u]+1];
                q.push(v);
            }
        }
    }
}
int mf=0;
int dfs(int p,int f){
    if(p==t){
        mf+=f;
        return f;
    }
    int u=0;
    for(int e=first[p];e;e=nxt[e]){
        if(w[e]&&dep[to[e]]==dep[p]-1){
            int uu=dfs(to[e],min(w[e],f-u));
            if(uu){
                w[e]-=uu;
                w[e^1]+=uu;
                u+=uu;
            }
            if(u==f)  return u;
        }
    }
    if(!--cnt[dep[p]]){
        dep[s]=n+m+3;
    }
    ++cnt[++dep[p]];
    return u;
}
int main(){
    n=Read(),m=Read(),e=Read();
    for(int i=1;i<=e;i++){
        int u=Read(),v=Read();
        if(u>n||v>m)  continue;
        Add(u,v+2005,1);
        Add(v+2005,u,0);
    }
    s=0,t=4005;
    for(int i=1;i<=n;i++){
        Add(s,i,1);
        Add(i,s,0);
    }
    for(int i=1;i<=m;i++){
        Add(i+2005,t,1);
        Add(t,i+2005,0);
    }
    Bfs(t);
    while(dep[s]<n+m+2){
        dfs(s,0x7ffffff);
    }
    cout<<mf<<endl;
}