POJ3041 二分图 最小点覆盖=最大匹配数

题意:有一个N*N的网格,该网格有K个障碍物.你有一把武器,每次你使用武器可以清楚该网格特定行或列的所有障碍.问你最少需要使用多少次武器能清除网格的所有障碍物?

分析:把网格的行看作左边点集的点,网格的列看成右边点集的点. 如果(i,j)格有障碍,那么就从左边i点到右边j点之间连接一条边,这样问题就转化为了求新图的最小点覆盖即最少选多少个点能够覆盖所有的边

利用二分图的特性最小点覆盖=最大匹配数，求新图最大匹配数即可。

匈牙利算法解法:

#include<iostream>
#include<algorithm>
#include<string>
#include<cstring>
#include<vector>
using namespace std;
const int maxn=505;
vector<int> g[maxn];
bool v[maxn];
int from[maxn];
bool find(int x)
{
    for(int i=0;i<g[x].size();i++)
    {
        if(!v[g[x][i]])
        {
            v[g[x][i]]=true;
            if(!from[g[x][i]]||find(from[g[x][i]]))
            {
                from[g[x][i]]=x;
                return true;
            }
        }
    }
    return false;
}
int solve(int n)
{
    int res=0;
    for(int i=1;i<=n;i++)
    {
        memset(v,0,sizeof v);
        if(find(i))
            res++;
    }
    return res;
}
int main()
{
    ios_base::sync_with_stdio(0);
    int n,m;
    cin>>n>>m;
    int x,y;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y;
        g[x].push_back(y);
    }
    cout<<solve(n)<<endl;
    return 0;
}

 

 

Hopcroft-Karp算法解法:

 

dx[ ],dy[ ]分别表示二分图左右部顶点的距离标号

mx[ ],my[ ]分别表示二分图左右部顶点的匹配节点

#include<iostream>
#include<algorithm>
#include<string>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int maxn=505;
vector<int> g[maxn];
bool v[maxn];
int dx[maxn],dy[maxn];
int mx[maxn],my[maxn];
bool find(int x)
{
    for(int i=0;i<g[x].size();i++)
    {
        if(!v[g[x][i]]&&dy[g[x][i]]==dx[x]+1)
        {
            v[g[x][i]]=true;
            if(!my[g[x][i]]||find(my[g[x][i]]))
            {
                mx[x]=g[x][i];
                my[g[x][i]]=x;
                return true;
            }
        }
    }
    return false;
}
int solve(int n)
{
    int res=0;
    while(true)
    {
        bool flag=false;
        queue<int> q;
        memset(dx,0,sizeof dx);
        memset(dy,0,sizeof dy);
        for(int i=1;i<=n;i++)
        {
            if(!mx[i])
                q.push(i);
        }
        while(!q.empty())
        {
            int now=q.front();q.pop();
            for(int i=0;i<g[now].size();i++)
            {
                if(!dy[g[now][i]])
                {
                    dy[g[now][i]]=dx[now]+1;
                    if(my[g[now][i]])
                    {
                        dx[my[g[now][i]]]=dy[g[now][i]]+1;
                        q.push(my[g[now][i]]);
                    }
                    else flag=1;
                }
            }
        }
        if(!flag) break;
        memset(v,0,sizeof v);
        for(int i=1;i<=n;i++)
        {
            if(!mx[i]&&find(i))
                res++;
        }
    }
    return res;
}
int main()
{
    ios_base::sync_with_stdio(0);
    int n,m;
    cin>>n>>m;
    int x,y;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y;
        g[x].push_back(y);
    }
    cout<<solve(n)<<endl;
    return 0;
}

 

两者相对比，匈牙利算法实现简单，是最经典的二分图匹配算法，而Hopcroft-Karp算法是对匈牙利算法的优化。利用匈牙利算法一次只能找到一条增广路径，而Hopcroft-Karp算法一次能找到多条不相交的增广路径，然后根据这些增广路径添加多个匹配。相当于批量处理。