P6113 【模板】一般图最大匹配

 真·快的一批

首先回顾以下匈牙利算法作的二分图匹配二分图最大匹配_xiyuping24的博客-CSDN博客

#include<cstdio>
#include<cstring>
using namespace std;

const int N = 1e3;
bool f[N][N];
bool used[N];
int match[N];
int n,m,e;

bool DFS(int pos)
{
    for(int i=1; i<=m; i++)
    {
        if(f[pos][i] && !used[i])
        {
            used[i] = true;
            if(!match[i] || DFS(match[i])) //如果这个点i还未匹配则pos和他匹配，如果这个点已经匹配，那么如果本来和他匹配的点match[i]还能找到另一个点匹配则pos把i“抢”过来，让match[i]去匹配另一个点，否则就不干涉i和match[i]匹配
            {
                match[i] = pos;
                return true;
            }
        }
    }
    return false; 
}

int main()
{
    scanf("%d%d%d",&n,&m,&e);
    for(int i=1; i<=e; i++)
    {
        int x,y; scanf("%d%d",&x,&y);
        if(x<=n && y<=m) f[x][y] = true; 
    }
    int ans = 0;
    for(int i=1; i<=n; i++)
    {
        memset(used,false,sizeof(used)); 
        if(DFS(i)) ans++;
    }
    printf("%d\n",ans);
    return 0;
}

然而，匈牙利只能处理二分图——这是因为二分图是保证没有奇环的，一旦遇上奇环匈牙利直接进死循环，所以本题算法带花树blossom是匈牙利+BFS处理奇环

介绍概念——花        花指的是对于一个有2*k+1个点的奇环，其内部最多有k个匹配，还有一个点与环外一点匹配，我们把这样一个环缩为点，形成的点就叫花。

具体怎么操作呢？由于出现奇环意味着有两条路走着走着碰上了，现在我们就是要找到这个相遇的点（记为花根）。找到花根后，我们继续处理环。用pre[v]数组记录环，一步步跳环的过程我们将整个花都染成了同一个颜色，那么此时这个花就可以当成一个该颜色的点来处理了（缩点，修改祖先操作用并查集维护即可）

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=100010;
int n,m,tot,ans,head[N],f[N],dfn[N],dfs_clock,match[N],pre[N],vis[N];
struct edge{int to,next;}e[N<<1];
inline int read()
{
    int x=0,f=1;
    char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline void add_edge(int u,int v)
{
    e[++tot].to=v;
    e[tot].next=head[u];
    head[u]=tot;
}
inline int find(int x)
{
    if(f[x]==x) return x;
    return f[x]=find(f[x]);
}
inline int LCA(int u,int v)
{
    ++dfs_clock;
    u=find(u),v=find(v);
    while(dfn[u]!=dfs_clock)
    {
        dfn[u]=dfs_clock;
        u=find(pre[match[u]]);
        if(v) swap(u,v);
    }
    return u;
}
queue<int>q;
inline void blossom(int u,int v,int w)
{
    while(find(u)!=w)
    {
        pre[u]=v,v=match[u];
        if(vis[v]==2) vis[v]=1,q.push(v);
        if(find(u)==u) f[u]=w;
        if(find(v)==v) f[v]=w;
        u=pre[v];
    }
}
inline int dfs(int s)
{
    for(int i=1;i<=n;i++) f[i]=i;
    memset(vis,0,sizeof vis);
    memset(pre,0,sizeof pre);
    while(!q.empty()) q.pop();
    q.push(s),vis[s]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(find(u)==find(v)||vis[v]==2) continue;
            if(!vis[v])
            {
                vis[v]=2,pre[v]=u;
                if(!match[v])
                {
                    for(int k=v,nxt;k;k=nxt)
                    {
                        nxt=match[pre[k]];
                        match[k]=pre[k];
                        match[pre[k]]=k;
                    }
                    return 1;
                }
                vis[match[v]]=1;
                q.push(match[v]);
            }
            else
            {
                int w=LCA(u,v);
                blossom(u,v,w);
                blossom(v,u,w);
            }
        }
    }
    return 0;
}
signed main()
{
    n=read(),m=read();
    for(int i=1;i<=m;i++)
    {
        int u=read();
        int v=read();
        add_edge(u,v);
        add_edge(v,u);
    }
    for(int i=1;i<=n;i++) if(!match[i]) ans+=dfs(i);
    printf("%lld\n",ans);
    for(int i=1;i<=n;i++) printf("%lld ",match[i]);
    return 0;
}