前置技能
匈牙利算法
增广路
从一个未匹配点到另一个未匹配点,中间经过的匹配边和未匹配边交替出现的一条路径
从上面的性质来看
每次找到一条增广路,增广路一定有奇数条边,而且未匹配边一定比匹配边多一
那么把匹配和未匹配做一遍类似异或的操作就能使答案
+1
+
1
如果找不到增广路那么就是最大匹配了
然后这就是匈牙利算法的思想
但是这只是对于二分图来讲的
而对于不能变成二分图的图,就不行了
比如这个
深色的为匹配边
这显然是增广路,但是显然不能这样,如果取反,肯定是不合法的
因为一个奇数的环中一点连了两条同为匹配或未匹配的边
此时就需要进行修改
带花树算法
对于每个奇环,肯定是有一个点不会和环内的点匹配的
那么我们可以不管这个环内的匹配,直接缩成一个点
只需要知道环内的走向,满足找到增广路后取反合法就好了,取反时展开环
算法过程
把点分成两类:
S
S
类和类
每次选一个
S
S
点出发增广
记录每个
T
T
点扩展而来的点
从
S
S
点扩展节点, 如果是走过的点, 直接跳过
如果
T
T
没走过, 并且没有被匹配, 那么找到了一条增广路,
此时直接往回走, 找到每个点的
pre
p
r
e
, 直接匹配这两个点,
然后跳到原来
pre
p
r
e
匹配的点上继续往回处理
相当于是对匹配边与未匹配边进行异或操作
否则如果
T
T
被匹配了, 那么把它匹配的点加入队列, 继续增广
以上是匈牙利算法的过程
重点是如果遇到了走过的点
此时就要进行”开花”的操作
首先找到这两个点的
LCA
L
C
A
, 准确来讲应该是这两个点所属”花”的
LCA
L
C
A
, 然后缩成一朵”大花”, 把它看成
S
S
点就好了
求就暴力求一下就好了
此时我们要考虑这朵”大花”内
pre
p
r
e
的变化
对于这两个点, 设为
x
x
, , 它们都是
S
S
点, 从走到了
y
y
往回跳到
每次跳到它的匹配点, 如果它是
T
T
点, 变成点, 丢进队列内
每次它和它的匹配点直接
pre
p
r
e
相互连
最后
x
x
, 的
pre
p
r
e
也相互连, 表示在同一个”花”内
每次找到增广路往回走到
x
x
, 到
y
y
这条边是未匹配的, 此时一定匹配了外面的一个点
那么就只要沿着
x
x
之前匹配的点往回继续走就好了
也就是说在”花”内这样连接, 就使得每次回到”花”时, 走的是那条未匹配的边回去
# include <bits/stdc++.h>
# define RG register
# define IL inline
# define Fill(a, b) memset(a, b, sizeof(a))
using namespace std;
typedef long long ll;
const int _(505);
typedef int Arr[_];
IL int Input(){
RG int x = 0, z = 1; RG char c = getchar();
for(; c < '0' || c > '9'; c = getchar()) z = c == '-' ? -1 : 1;
for(; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * z;
}
Arr first, match, fa, vis, tim, pre;
int n, m, cnt, idx, ans;
queue <int> Q;
struct Edge{
int to, next;
} edge[_ * _];
IL void Add(RG int u, RG int v){
edge[cnt] = (Edge){v, first[u]}, first[u] = cnt++;
}
IL int Find(RG int x){
return x == fa[x] ? x : fa[x] = Find(fa[x]);
}
IL int LCA(RG int x, RG int y){
++idx, x = Find(x), y = Find(y);
while(tim[x] != idx){
tim[x] = idx;
x = Find(pre[match[x]]);
if(y) swap(x, y);
}
return x;
}
IL void Blossom(RG int x, RG int y, RG int p){
while(Find(x) != p){
pre[x] = y, y = match[x];
if(vis[y] == 2) vis[y] = 1, Q.push(y);
if(Find(x) == x) fa[x] = p;
if(Find(y) == y) fa[y] = p;
x = pre[y];
}
}
IL int Aug(RG int S){
while(!Q.empty()) Q.pop();
Fill(vis, 0), Fill(pre, 0);
for(RG int i = 1; i <= n; ++i) fa[i] = i;
Q.push(S), vis[S] = 1;
while(!Q.empty()){
RG int u = Q.front(); Q.pop();
for(RG int e = first[u]; e != -1; e = edge[e].next){
RG int v = edge[e].to;
if(Find(u) == Find(v) || vis[v] == 2) continue;
if(!vis[v]){
vis[v] = 2, pre[v] = u;
if(!match[v]){
for(RG int x = v, lst; x; x = lst)
lst = match[pre[x]], match[x] = pre[x], match[pre[x]] = x;
return 1;
}
vis[match[v]] = 1, Q.push(match[v]);
}
else if(vis[v] == 1){
RG int p = LCA(u, v);
Blossom(u, v, p);
Blossom(v, u, p);
}
}
}
return 0;
}
int main(RG int argc, RG char *argv[]){
Fill(first, -1);
n = Input(), m = Input();
for(RG int i = 1, u, v; i <= m; ++i)
u = Input(), v = Input(), Add(u, v), Add(v, u);
for(RG int i = 1; i <= n; ++i) if(!match[i]) ans += Aug(i);
printf("%d\n", ans);
for(RG int i = 1; i <= n; ++i) printf("%d ", match[i]);
return puts(""), 0;
}