圖的最大匹配算法

定義：在一個無向圖中，定義一條邊覆蓋的點為這條邊的兩個端點。找到一個邊集S包含最多的邊，使得這個邊集覆蓋到的所有頂點中的每個頂點只被一條邊覆蓋。S的大小叫做圖的最大匹配。

二分圖的最大匹配算法：設左邊集合為A集合，有邊集合為B集合。二分圖最大匹配常用的有兩種方法。

（1）第一種方法叫做匈牙利算法。這個方法依次枚舉A中的每個點，試圖在B集合中找到一個匹配。對於A集合中一點x，假設B集合中有一個與其相連的點y，若y暫時還沒有匹配點，那么x可以和y匹配，找到；否則，設y已經匹配的點為z（顯然z是A集合中的一個點），那么，我們將嘗試為z找到一個除了y之外的匹配點，若找到，那么x可以和y匹配，否則x不能與y匹配。

我們以下圖為例說明匈牙利匹配算法。

step1：從1開始，找到右側的點4，發現點4沒有被匹配，所以找到了1的匹配點為4 。得到如下圖：

step2：接下來，從2開始，試圖在右邊找到一個它的匹配點。我們枚舉5，發現5還沒有被匹配，於是找到了2的匹配點，為5.得到如下圖：

step3:接下來，我們找3的匹配點。我們枚舉了5，發現5已經有了匹配點2。此時，我們試圖找到2除了5以外的另一個匹配點，我們發現，我們可以找到7，於是2可以匹配7，所以5可以匹配給3，得到如下圖：

此時，結束，我們得到最大匹配為3。

（2）第二種方法叫做Hopcroft-Karp算法。這個算法大致思想與第一個方法相同。不同之處在於，這個方法每次找到一組互不相交的增廣路徑。我們用下面的例子說明。

step1：我們從所有未找到增廣路徑的點，也就是1,2,3,4開始，找增廣路徑，我們找到了1->2,3->3兩條（左邊的紅線表示增廣路徑），然后沿着這些增廣路徑求匹配點，得到了右邊的圖，即1匹配2,3匹配3。

一般圖的最大匹配算法：我們從一個沒有匹配的節點s開始，使用BFS生成搜索樹。每當發現一個節點u，如果u還沒有被匹配，那么就可以進行一次成功的增廣，即s匹配u；否則，我們就把節點u和它的配偶v一同接到樹上，之后把ｖ丟進隊列繼續搜索。我們給每個在搜索樹上的點一個類型：S或者T。當ｕ把它的配偶ｖ扔進隊列的時候，我們把ｕ標記為T型，ｖ標記為S型。於是，搜索樹的樣子是這樣的：

否則，我們找到了一個長度為奇數的環，如下圖所示

 就要進行一次“縮花”的操作！所謂縮花操作，就是把這個環縮成一個點。這個圖縮花之后變成了５個點（一個大點，或者叫一朵花，加原來的４個點）：縮點完成之后，還要把原來環里面的T型點統統變成S型點，如下圖

之所以能縮成一個點，是因為，一個長度為奇數的環（例如上圖中的s-b-d-j-f-c-a-s），如果我們能夠給它中的任意一個點找一個出度，那么環中的其他點正好可以配成對，這說明，每個點的出度都是等效的。這就是縮點的思想來源。

 

 

 
無向圖最大匹配實現：

#define MAXN 250

class GraphMaxMatch
{
private:
    int que[MAXN],queHead,queTail;
    bool g[MAXN][MAXN];
    bool inque[MAXN],inblossom[MAXN];
    int match[MAXN],pre[MAXN],S[MAXN];
    int n;

    void addQueEle(int u)
    {
        if(inque[u]) return;
        inque[u]=1;
        que[queTail++]=u;
        if(queTail==MAXN) queTail=0;
    }
    int popQueEle()
    {
        int u=que[queHead++];
        if(queHead==MAXN) queHead=0;
        return u;
    }

    int findancestor(int u,int v)
    {
        int visit[MAXN];
        memset(visit,0,sizeof(visit));
        while(1)
        {
            u=S[u];
            visit[u]=1;
            if(match[u]==-1) break;
            u=pre[match[u]];
        }
        while(1)
        {
            v=S[v];
            if(visit[v]) break;
            v=pre[match[v]];
        }
        return v;
    }
    void reset(int u,int root)
    {
        int v;
        while(u!=root)
        {
            v=match[u];
            inblossom[S[u]]=1;
            inblossom[S[v]]=1;
            v=pre[v];
            if(S[v]!=root) pre[v]=match[u];
            u=v;
        }
    }

    void contract(int u,int v)
    {
        int root=findancestor(u,v);
        memset(inblossom,0,sizeof(inblossom));
        reset(u,root); reset(v,root);
        if(S[u]!=root) pre[u]=v;
        if(S[v]!=root) pre[v]=u;
        for(int i=1;i<=n;i++) if(inblossom[S[i]])
        {
            S[i]=root;
            addQueEle(i);
        }
    }

    bool BFS(int start)
    {
        for(int i=1;i<=n;i++) pre[i]=-1,inque[i]=0,S[i]=i;
        queHead=queTail=0;
        addQueEle(start);
        while(queHead!=queTail)
        {
            int u=popQueEle();

            for(int v=1;v<=n;v++) if(g[u][v]&&S[v]!=S[u]&&match[u]!=v)
            {
                if(v==start||match[v]!=-1&&pre[match[v]]!=-1)
                {
                    contract(u,v);
                }
                else if(pre[v]==-1)
                {
                    pre[v]=u;
                    if(match[v]!=-1) addQueEle(match[v]);
                    else
                    {
                        u=v;
                        while(u!=-1)
                        {
                            v=pre[u];
                            int tmp=match[v];
                            match[u]=v;
                            match[v]=u;
                            u=tmp;
                        }
                        return true;
                    }
                }
            }
        }
        return false;
    }
public:
    /**
    vertexNum: vertex number
    G[1~vertexNum][1~vertexNum]: edge relation
    */
    vector<pair<int,int> > calMaxMatch(
                int vertexNum,const bool G[MAXN][MAXN])
    {
        n=vertexNum;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++) g[i][j]=G[i][j];
        }
        memset(match,-1,sizeof(match));
        for(int i=1;i<=n;i++) if(match[i]==-1) BFS(i);

        vector<pair<int,int> > ans;
        for(int i=1;i<=n;i++)
        {
            if(match[i]!=-1&&match[i]>i)
            {
                ans.push_back(make_pair(i,match[i]));
            }
        }
        return ans;
    }
};