【UOJ】#79. 一般图最大匹配

题解

板子！我相信其实没人来看我的板子！但是为了防止我忘记，我还是要写点什么

我们考虑二分图，为什么二分图就能那么轻松地写出匹配的代码呢？因为匹配只会发生在黑点和白点之间，我们找寻增广路，必然是一黑一白一黑一白这么走

然而，一般图由于有了奇环，事情变得不妙了啊

奇环上的所有点，可以是……任意的奇偶性（起点到它的距离的奇偶性，可以是非简单路径）

那么我们就让任意奇偶性的点可以进行匹配就可以了，我们通过pre维护出一条路径到达根节点

怎么维护呢？缩花！

花？什么是花？

花就是奇环，我们找到花托（两个点的最近公共祖先），从两个点构建一条能走到花托的路径
如何构建
对于(u,v)和花托f
我们让u的pre走到v，然后令u跳到u匹配点的pre,v变成u的匹配点，继续这个操作，同时把这个匹配点改成偶点(可进行增广）
对v走到花托走到f进行类似的操作

代码

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#define enter putchar('\n')
#define space putchar(' ')
#define MAXN 505
//#define ivorysi
using namespace std;
typedef long long int64;
template<class T>
void read(T &res) {
    res = 0;char c = getchar();T f = 1;
    while(c < '0' || c > '9') {
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9') {
        res = res * 10 + c - '0';
        c = getchar();
    }
    res *= f;
}
template<class T>
void out(T x) {
    if(x < 0) {putchar('-');x = -x;}
    if(x >= 10) {
        out(x / 10);
    }
    putchar('0' + x % 10);
}
struct node {
    int to,next;
}E[MAXN * MAXN * 2];
int sumE,head[MAXN];
int N,M,fa[MAXN],pre[MAXN],matk[MAXN],sta[MAXN];
int Q[MAXN],L,R;
void add(int u,int v) {
    E[++sumE].to = v;
    E[sumE].next = head[u];
    head[u] = sumE;
}
int getfa(int x) {
    return fa[x] == x ? x : fa[x] = getfa(fa[x]);
}
int lca(int x,int y) {
    static int vis[MAXN],Tim;
    ++Tim;
    while(1) {//每个点都尝试走一步
        x = getfa(x);
        if(x) {
            if(vis[x] == Tim) {
                return x;
            }
            else vis[x] = Tim,x = pre[matk[x]];
        }
        swap(x,y);
    }
}
void blossom(int u,int v,int flower_root) {
    while(getfa(u) != flower_root) {
        pre[u] = v;
        //我们每个点既然都是奇偶难分（雾）
        //就构建出一条这个点走到花托的交错路
        //构建方法就是顺着匹配边往上跳
        //这个时候我们碰到的匹配点还都以为自己是偶点= =（奇怪的叙述）
        int m = matk[u];
        if(sta[m] == 1) {sta[m] = 0;Q[++R] = m;}
        //把所有以为自己是奇点的人告诉他们可以当偶点啦
        if(u == fa[u]) fa[u] = flower_root;
        if(m == fa[m]) fa[m] = flower_root;
        v = m,u = pre[m];
    }
}
bool match(int s) {
    //sta : -1 未访问 0:偶点（起始点）  1:奇点
    //pre : 交错树上的父亲，任意一点顺着当前自己的匹配点的pre会走到树根，也就是还原出了交错路
    L = 1,R = 0;Q[++R] = s;
    
    memset(sta,-1,sizeof(sta));
    memset(pre,0,sizeof(pre));
    sta[s] = 0;//起点是偶点
    for(int i = 1 ; i <= N ; ++i) fa[i] = i; 
    while(L <= R) {
        int u = Q[L++];
        for(int i = head[u] ; i ; i = E[i].next) {
            int v = E[i].to;
            if(sta[v] == -1) {
                pre[v] = u;sta[v] = 1;
                if(!matk[v]) {
                    for(int j = u , k = v,last; ; j = pre[k = last]) {
                        last = matk[j],matk[j] = k;matk[k] = j;
                        if(!last) break;
                    }//顺着pre节点找交错路，全部取反
                    return 1;
                }
                sta[matk[v]] = 0;
                Q[++R] = matk[v];
            }
            else if(getfa(v) != getfa(u) && !sta[v]) {
                int f = lca(u,v);blossom(u,v,f);blossom(v,u,f);
                //两个偶点，缩花，两条路径爬到父亲
            }
        }
    }
    return 0;
}
void Init() {
    read(N);read(M);
    int u,v;
    for(int i = 1 ; i <= M ; ++i) {
        read(u);read(v);
        add(u,v);add(v,u);
    }
}
void Solve() {
    int ans = 0;
    for(int i = 1 ; i <= N ; ++i) {
        if(!matk[i] && match(i)) ++ans;
    }
    out(ans);enter;
    for(int i = 1 ; i <= N ; ++i) {
        out(matk[i]);
        if(i == N) enter;
        else space;
    }
}
int main() {
#ifdef ivorysi
    freopen("f1.in","r",stdin);
#endif
    Init();
    Solve();
}

//5aaC5p6c5oiR5LiK5LiN5LqGdGh177yM5oiR5bCx5YaN5Lmf6KeB5LiN5Yiw54yr6ZSf5LqG
//4oCm4oCm54yr6ZSf55yf5Y+v54ix