带花树

作用

求二分图的最大匹配可以用匈牙利算法来做,但是一般图则就要用带花树.
因为二分图中只有偶环(有偶数条边的环)而没有奇环,若用匈牙利算法则会出现一个点存在于两个匹配中或是遗漏情况(匈牙利算法在查找中只会在答案增加时替换,不会直接替换).
因此相比于匈牙利算法,带花树有针对奇环的操作.

实现方法

每次搜索先取一个未匹配点,以它为起点,并对其进行标号(1或2,其他点的标号等清零),用于判断其他点在这次搜索中有无搜到过,以及它遇到的点和它组成的是奇环还是偶环,而且在后续操作中只会对标号与点相同的点进行搜索.
遍历它的边,根据与它连接的点的标号进行判断:
一.若这个点还没标号,则说明它在这次搜索中还未被匹配,再次分类:
1.若它还未匹配,则说明找到了一个新的匹配方法,将它到起点中的匹配全部更改,使得总匹配数加一.
2.若它已经匹配,则将其和它的匹配对象标号,并搜索它的匹配对象,记录下这个点到此时搜索的点的路径,各种路径将形成一棵搜索树.
二.若连接的点于它标号不同,则这个点与它组成的是偶环且已经匹配,无视它.
三.若连接的点与它标号相同,则这个点与它组成的是奇环,也就是带花树主要要解决的问题,进行如下操作:
为了能继续搜索,可以将奇环当做一朵树上的花(一个大点多余的点均可以两两匹配),那我们就要进行缩点:
一.找到两点LCA,用最暴力的方法找.
二.缩点,主要进行如下三个操作:
1.更新路径,原来的路径都是指向前一个点,而现在要使它沿着环.
2.用并查集记录它属于哪一朵花,更新花上部分点的父亲节点,要注意的是.
3.因为是环,因此标号可以转换,因而将环上所有点的标号都改为与起点相同并放入队列以进行搜索.
最后统计每次搜索增加的匹配数即可.
实现起来有点麻烦,可以通过看代码来弄懂.

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define N 310
using namespace std;

int m,n,bb,ans,first[N],mat[N],fa[N],pre[N],bj[N],tim,tic[N];
bool mm[N][N];
struct Bn
{
    int to,next;
} bn[N*N];
queue<int>que;

inline void add(int u,int v)
{
    bb++;
    bn[bb].to=v;
    bn[bb].next=first[u];
    first[u]=bb;
}

int ff(int u)//并查集
{
    return fa[u]==u?u:fa[u]=ff(fa[u]);
}

inline void hb(int u,int v,int l)//缩点
{
    for(; ff(u)!=l; )
    {
        pre[u]=v;//操作1
        if(fa[u]==u) fa[u]=l;
        if(fa[mat[u]]==mat[u]) fa[mat[u]]=l;//操作2
        if(bj[mat[u]]==2)
        {
            bj[mat[u]]=1;
            que.push(mat[u]);//操作3
        }
        v=mat[u];
        u=pre[v];
    }
}

inline int lca(int u,int v)//寻找最近公共祖先
{
    u=ff(u),v=ff(v);
    for(tim++;;)
    {
        tic[u]=tim;
        u=mat[u];
        if(!u) break;
        u=ff(pre[u]);
    }
    for(; tic[v]!=tim; v=ff(pre[mat[v]]));
    return v;
}

inline bool bfs(int u)
{
    int i,j,p,q,tmp,l;
    for(i=1; i<=n; i++) fa[i]=i;
    memset(pre,0,sizeof(pre));//pre记录个点间的路径
    memset(bj,0,sizeof(bj));//记录每个点的标号
    for(; !que.empty(); que.pop());//队列清空
    //以上为初始化
    que.push(u);
    bj[u]=1;
    for(; !que.empty();)
    {
        q=que.front();
        que.pop();
        for(p=first[q]; p!=-1; p=bn[p].next)
        {
            if(bj[bn[p].to]==2||ff(q)==ff(bn[p].to)) continue;
            //在同一朵花上或形成了偶环
            if(!bj[bn[p].to])
            {
                pre[bn[p].to]=q;
                bj[bn[p].to]=2;
                if(!mat[bn[p].to])
                {
                    for(i=bn[p].to; i; i=l)
                    {
                        tmp=pre[i];
                        l=mat[tmp];
                        mat[i]=tmp;
                        mat[tmp]=i;
                    }
                    return 1;
                }
                bj[mat[bn[p].to]]=1;
                que.push(mat[bn[p].to]);
            }
            else if(bj[bn[p].to]==1)
            {
                tmp=lca(q,bn[p].to);
                hb(bn[p].to,q,tmp);
                hb(q,bn[p].to,tmp);
            }
        }
    }
    return 0;
}

int main()
{
    register int i,j,k,p,q;
    memset(first,-1,sizeof(first));
    scanf("%d%d",&n,&m);
    for(i=1; i<=m; i++)
    {
        scanf("%d%d",&p,&q);
        add(p,q),add(q,p);
    }
    for(i=1; i<=n; i++)
    {
        ans+=(!mat[i]&&bfs(i));
    }
    printf("%d\n",ans);
}