二分图匹配学习小结

二分图

当这个图可以被分成两个集合（一般称为X部和Y部），且所有边的两个端点分别在X部和Y部时，此为二分图

引题：SGU172

题意：给出一个图，判断其是否是二分图，如果是，输出其中一部
其实就是搜索染色

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int N=2005;
vector<int>edge[N];
int color[N];
bool vis[N];
int ans[N];
bool dfs(int u){
    vis[u]=1;
    bool k=false;
    for(unsigned int i=0;i<edge[u].size();i++){
        int v=edge[u][i];
        if(vis[v]){
            if(color[v]==color[u])
                return true;
            continue ;
        }
        color[v]=!color[u];
        k|=dfs(v);
    }
    return k;
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        edge[u].push_back(v);
        edge[v].push_back(u);
    }
    for(int i=1;i<=n;i++){
        if(!vis[i]&&dfs(i)){
            printf("no\n");
            return 0;
        }
    }
    printf("yes\n");
    int cnt=0;
    for(int i=1;i<=n;i++)
        if(!color[i]){
            cnt++;
            ans[cnt]=i;
        }
    printf("%d\n",cnt);
    for(int i=1;i<=cnt;i++)
        printf("%d ",ans[i]);
}

---

给定一个二分图G，在G的一个子图M中，M的边集{E}中的任意两条边都不交汇于同一个结点，则称M是一个匹配
选择边数最大的子图称为图的最大匹配
如果一个匹配中，图中的每个顶点都和图中某条边相关联，则称此匹配为完全匹配，也称作完备匹配
那么，问题来了，怎么求二分图最大匹配呢
我们可以虚拟一个S和T，S向X部连一条容量为1的边，Y部向T连一条容量为1的边，跑最大流
不过二分图匹配其实还有一种算法

匈牙利算法

匈牙利数学家Edmonds提出
我们先要知道几个新概念
交错路 边属于M和边属于G-M的交替出现的路径
增广路径 连通两个异部未匹配点的交错路，特别的，直接连接两个为匹配点的边也是增广路径
我们可以发现，当存在一条增广路径时，我们如果将这条路径上所有在M的边剔除，不在M的边放入M，M仍是一个匹配，且匹配数增加了1
这就是匈牙利算法的基本原理：寻找增广路径
匈牙利算法寻找增广路径的方法是：
枚举X部点u，枚举其邻接点v，
1）若v未匹配，将(u,v)加入匹配
2) 若v已匹配，寻找从v的匹配点u’能否寻找到一条增广路
时间复杂度O(nm)
代码

vector<int>edge[N];
int mx[N];
int my[N];
bool vis[N];
bool dfs(int u){
    for(unsigned int i=0;i<edge[u].size();i++){
        int v=edge[u][i];
        if(vis[v])
            continue;
        vis[v]=1;
        if(my[v]==-1||dfs(my[v])){
            mx[u]=v;
            my[v]=u;
            return true;
        }
    }
    return false;
}

一些性质

最大匹配：定义见上
最小覆盖点数： 使所有边都至少有一个点存在点集V中的V的最小大小
最小覆盖边数： 是所有点都至少是一个边集E中的边的一个端点的最小大小
最大独立集： 选出最多的顶点，使得任两点之间没有边相连
最小路径覆盖：给定一个有向无环图，用最少的路径数量去保证所有点都被覆盖住

最大匹配=最小覆盖点数=nx+ny–最小覆盖边数=nx+ny-最大独立集=n-最小路径覆盖

（注意尽管求最小路径覆盖的时候需要拆点，但是用拆点前的n来-最大匹配来得到最小路径覆盖）

习题

POJ 3041 Asteroids

题意：给出一个地图，X表示陨石，.表示空地，一束激光能够击穿整个一行或一列，请问最少需要几束激光就能消灭所有陨石

题解

我们把行作为x部，列作为y部，如果(a,b)有陨石，我们就在a、b间连一条边
答案就是最大匹配数

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int N=2005,L=20;
vector<int>edge[N];
int ma[N];
bool vis[N];
bool dfs(int u){
    for(unsigned int i=0;i<edge[u].size();i++){
        int v=edge[u][i];
        if(vis[v])
            continue;
        vis[v]=1;
        if(!ma[v]||dfs(ma[v])){
            ma[v]=u;
            return true;
        }
    }
    return false;
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        edge[u].push_back(v);
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        memset(vis,0,sizeof vis);
        ans+=dfs(i);
    }
    printf("%d\n",ans);
}

POJ 2226 Muddy Fields

题意：给出一个地图，*表示沼泽，.表示草地，用一些一边为1另一边长度任意的木板来覆盖住所有的沼泽，且不压任何草地，询问至少要几块木板

题解

乍一看跟上面那道挺像的
实际上由于草地的限制，我们不能直接把行、列作为点，而是应该按照被.分开的来建点，具体见代码

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int N=2005,L=20;
vector<int>edge[N];
int ma[N];
bool vis[N];
bool dfs(int u){
    for(unsigned int i=0;i<edge[u].size();i++){
        int v=edge[u][i];
        if(vis[v])
            continue;
        vis[v]=1;
        if(!ma[v]||dfs(ma[v])){
            ma[v]=u;
            return true;
        }
    }
    return false;
}
char gr[N][N];
int cx[N][N],cy[N][N];
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%s",gr[i]+1);
    }
    int cntx=1,cnty=1;
    for(int i=1;i<=n;i++){
        if(gr[i-1][m]=='*')
            cntx++;
        for(int j=1;j<=m;j++){
            if(gr[i][j]=='*')
                cx[i][j]=cntx;
            else if(gr[i][j-1]=='*')
                cntx++;
        }
    }
    if(gr[n][m]=='.')
        cntx--;
    for(int j=1;j<=m;j++){
        if(gr[n][j-1]=='*')
            cnty++;
        for(int i=1;i<=n;i++){
            if(gr[i][j]=='*')
                cy[i][j]=cnty;
            else if(gr[i-1][j]=='*')
                cnty++;
        }
    }
    if(gr[n][m]=='.')
        cnty--;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            if(gr[i][j]=='*')
                edge[cx[i][j]].push_back(cy[i][j]);
        }
    int ans=0;
    for(int i=1;i<=cntx;i++){
        memset(vis,0,sizeof vis);
        ans+=dfs(i);
    }
    printf("%d\n",ans);
}

POJ 1422 Air Raid

题意：n个点形成的有向图，无环，求最小路径覆盖（每个点只能覆盖一次）

题解

拆点，将每个点拆成前驱和后继，连边，答案是n-最大匹配

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int N=2505,M=10000,L=20;
struct node{
    int v,nxt;
}edge[M];
int head[N],mcnt;
void add_edge(int u,int v){
    mcnt++;
    edge[mcnt].v=v;
    edge[mcnt].nxt=head[u];
    head[u]=mcnt;
}
bool vis[N];
int mx[N];
int my[N];
bool dfs(int u){
    for(int i=head[u];i;i=edge[i].nxt){
        int v=edge[i].v;
        if(vis[v])
            continue ;
        vis[v]=1;
        if(my[v]==0||dfs(my[v])){
            mx[u]=v;
            my[v]=u;
            return true;
        }
    }
    return false;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--){
        int n,m;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            add_edge(u,v);
        }
        int ans=0;
        memset(mx,0,sizeof mx);
        memset(my,0,sizeof my);
        for(int i=1;i<=n;i++){
            memset(vis,0,sizeof vis);
            if(mx[i]==0)
                ans+=dfs(i);
        }
        printf("%d\n",n-ans);
        memset(head,0,sizeof head);
        mcnt=0;
    }
}

POJ 2594 Treasure Exploration

题意：n个点形成的有向图，无环，求最小路径覆盖（每个点可以覆盖多次）

题解

由于每个点可以覆盖多次，直接的二分图匹配就不行了（想一想为什么）
这时候呢，最好的方法就是
跑一遍floyd，传递连通性
根据新的连通性，就等同于之前那道题了