【转】带花树（一般无向图的最大匹配）

原文链接：http://fanhq666.blog.163.com/blog/static/8194342620120304463580/

它的核心思想还是找增广路。假设已经匹配好了一堆点，我们从一个没有匹配的节点s开始，使用BFS生成搜索树。每当发现一个节点u，如果u还没有被匹配，那么就可以进行一次成功的增广；否则，我们就把节点u和它的配偶v一同接到树上，之后把ｖ丢进队列继续搜索。我们给每个在搜索树上的点一个类型：S或者T。当ｕ把它的配偶ｖ扔进队列的时候，我们把ｕ标记为T型，ｖ标记为S型。于是，搜索树的样子是这样的：

　　　　　　　ｓ
　　　　　　／　　＼
　　　　　ａ　　　　ｂ
　　　　　｜　　　　｜
　　　　　ｃ　　　　ｄ
　　　　／　＼　　／　＼
　　　　ｅ　ｆ　　ｕ　ｊ
　　　　｜　｜　　｜　｜
　　　　ｉ　ｊ　　ｖ　ｋ
其中，黑色竖线相连的两个点是已经匹配好的，蓝色斜线表示两个点之间有边，但是没有配对。T型的用红色，S型的用黑色。


这里有个小问题：一个S型点ｄ在某一步扩展的时候发现了点ｕ，如果ｕ已经在搜索树上了（即，出现了环），怎么办？
我们规定，如果ｕ的类型是T型，就无视这次发现；（这意味着我们找到了一个长度为偶数的环，直接无视）
　　　　　　　ｓ
　　　　　　／　　＼
　　　　　ａ　　　　ｂ
　　　　　｜　　　　｜
　　　　　ｃ　　　　ｄ　　　如果连出来的边是指向T型点的，就无视这个边。
　　　　／　＼　　／　＼
　　　　ｅ　ｆ＜－　　ｇ
　　　　｜　｜　　　　｜
　　　　ｉ　ｊ　　　　ｋ
否则，我们找到了一个长度为奇数的环，就要进行一次“缩花”的操作！所谓缩花操作，就是把这个环缩成一个点。
　　　　　　　ｓ
　　　　　　／　　＼
　　　　　ａ　　　　ｂ
　　　　　｜　　　　｜
　　　　　ｃ　　　　ｄ
　　　　／　＼　　／　＼
　　　　ｅ　ｆ　　｜　ｇ
　　　　｜　｜　　｜　｜
　　　　ｉ　ｕ＜－＋　ｋ
这个图缩花之后变成了５个点（一个大点，或者叫一朵花，加原来的４个点）：
缩点完成之后，还要把原来环里面的T型点统统变成S型点，之后扔到队列里去。
　　＋－－－－－－－－－－－－－＋
　　｜　　　　　　　　　　　　　｜
　　｜　　　　　ｓ　　　　　　　｜
　　｜　　　　／　　＼　　　　　｜
　　｜　　　ａ　　　　ｂ　　　　｜
　　｜　　　｜　　　　｜　　　　｜　　　现在是一个点了！还是一个S点。
　　｜　　　ｃ　　　　ｄ　　　　｜
　　｜　　／　＼　　／　＼　　　｜
＋－｜－－　　ｆ－－ｕ　　－－－｜－－－＋
｜　｜　　　　　　　　　　　　　｜　　　｜
｜　｜　　　　　　　　　　　　　｜　　　｜
｜　｜　　　　　　　　　　　　　｜　　　｜
｜　＋－－－－－－－－－－－－－＋　　　｜
｜　　　　　　　　　　　　　　　　　　　｜
ｅ　　　　　　　　　　　　　　　　　　　ｇ
｜　　　　　　　　　　　　　　　　　　　｜
ｉ　　　　　　　　　　　　　　　　　　　ｋ
为什么能缩成一个点呢？我们看一个长度为奇数的环（例如上图中的ｓ－ｂ－ｄ－ｊ－ｆ－ｃ－ａ－），如果我们能够给它中的任意一个点找一个出度（配偶），那么环中的其他点正好可以配成对，这说明，每个点的出度都是等效的。例如，假设我们能够给图中的点ｄ另找一个配偶（例如ｄ＇好了），那么，环中的剩下６个点正好能配成３对，一个不多，一个不少（算上ｄ和ｄ＇一共４对刚刚好）。
ａ－ｓ－ｂ－ｄ－ｄ＇　　　　　　　　　ａ　ｓ－ｂ　ｄ－ｄ＇
　＼　　　　｜　　　　　　　＝＞　　　　＼　　　　　
　　ｃ－ｆ－ｕ　　　　　　　　　　　　　　ｃ　ｆ－ｕ
这就是我们缩点的思想来源。有一个劳苦功高的计算机科学家证明了：缩点之前和缩点之后的图是否有增广路的情况是相同的。
缩起来的点又叫一朵花（ｂｌｏｓｓｏｍ）．
注意到，组成一朵花的里面可能嵌套着更小的花。


当我们最终找到一条增广路的时候，要把嵌套着的花层层展开，还原出原图上的增广路出来。


嗯，现在你对实现这个算法有任何想法吗？
天啊，还要缩点……写死谁。。。。。。
我一开始也是这么想的。
我看了一眼网上某个大牛的程序，之后结合自己的想法，很努力地写出了一个能AC的版本。
实现的要点有什么呢？
首先，我们不“显式”地表示花。我们记录一个Nｅｘｔ数组，表示最终增广的时候的路径上的后继。同时，我们维护一个并查集，表示每个点现在在以哪个点为根的花里（一个花被缩进另一朵花之后就不算花了）。还要记录每个点的标记。
主程序是一段BFS。对于每个由ｘ发展出来的点ｙ，分４种情况讨论：
１。ｘｙ是配偶（不说夫妻，这是非二分图。。。）或者ｘｙ现在是一个点（在一朵花里）：直接无视
２。ｙ是T型点：直接无视
３。ｙ目前单身：太好了，进行增广！
４。ｙ是一个S型点：缩点！缩点！
缩点的时候要进行的工作：
１。找ｘ和ｙ的LCA（的根）ｐ。找LCA可以用各种方法。。。直接朴素也行。
２。在Nｅｘｔ数组中把ｘ和ｙ接起来（表示它们形成环了！）
３。从ｘ、ｙ分别走到ｐ，修改并查集使得它们都变成一家人，同时沿路把Nｅｘｔ数组接起来。


Nｅｘｔ数组很奇妙。每时每刻，它实际形成了若干个挂在一起的双向链表来表示一朵花内部的走法。
　　　　　－－－－
　　　　／　　　　＼＜－－＋
　　　　｜　　　　｜　　　｜
　　　　｜　　　　｜＜－－＋
　　　　ｖ　　　　ｖ
　　　－－－－－－－－－－
　　／　　　　　　　　　　＼
＋－　　　　　　　　　　　　－－＋
｜　　　　　　　　　　　　　　　｜
｜　　　　　　　　　　　　　　　｜

＋－－－－＞ｓ　　＜－－－－－－＋

然后就在网上找找看有没有神马模板代码之类的，在http://twinsclover.is-programmer.com/posts/21598.html的博客里找到一个

[cpp]  view plain copy

1. #include <iostream>  
2. #include <stdio.h>  
3. #include <string.h>  
4. #include <cmath>  
5. #include <algorithm>  
6. #include <queue>  
7.   
8. using namespace std;  
9. #define MAXE 250*250*2  
10. #define MAXN 250  
11. #define SET(a,b) memset(a,b,sizeof(a))  
12. deque<int> Q;  
13. //g[i][j]存放关系图：i,j是否有边,match[i]存放i所匹配的点  
14. bool g[MAXN][MAXN],inque[MAXN],inblossom[MAXN];  
15. int match[MAXN],pre[MAXN],base[MAXN];  
16.    
17. //找公共祖先  
18. int findancestor(int u,int v)  
19. {  
20.     bool inpath[MAXN]={false};  
21.     while(1)  
22.     {  
23.         u=base[u];  
24.         inpath[u]=true;  
25.         if(match[u]==-1)break;  
26.         u=pre[match[u]];  
27.     }  
28.     while(1)  
29.     {  
30.         v=base[v];  
31.         if(inpath[v])return v;  
32.         v=pre[match[v]];  
33.     }  
34. }  
35.    
36. //压缩花  
37. void reset(int u,int anc)  
38. {  
39.     while(u!=anc)  
40.     {  
41.         int v=match[u];  
42.         inblossom[base[u]]=1;  
43.         inblossom[base[v]]=1;  
44.         v=pre[v];  
45.         if(base[v]!=anc)pre[v]=match[u];  
46.         u=v;  
47.     }  
48. }  
49.    
50. void contract(int u,int v,int n)  
51. {  
52.     int anc=findancestor(u,v);  
53.     SET(inblossom,0);  
54.     reset(u,anc);reset(v,anc);  
55.     if(base[u]!=anc)pre[u]=v;  
56.     if(base[v]!=anc)pre[v]=u;  
57.     for(int i=1;i<=n;i++)  
58.         if(inblossom[base[i]])  
59.         {  
60.             base[i]=anc;  
61.             if(!inque[i])  
62.             {  
63.                 Q.push_back(i);  
64.                 inque[i]=1;  
65.             }  
66.         }  
67. }  
68.    
69. bool dfs(int S,int n)  
70. {  
71.     for(int i=0;i<=n;i++)pre[i]=-1,inque[i]=0,base[i]=i;  
72.     Q.clear();Q.push_back(S);inque[S]=1;  
73.     while(!Q.empty())  
74.     {  
75.         int u=Q.front();Q.pop_front();  
76.         for(int v=1;v<=n;v++)  
77.         {  
78.             if(g[u][v]&&base[v]!=base[u]&&match[u]!=v)  
79.             {  
80.                 if(v==S||(match[v]!=-1&&pre[match[v]]!=-1))contract(u,v,n);  
81.                 else if(pre[v]==-1)  
82.                 {  
83.                     pre[v]=u;  
84.                     if(match[v]!=-1)Q.push_back(match[v]),inque[match[v]]=1;  
85.                     else  
86.                     {  
87.                         u=v;  
88.                         while(u!=-1)  
89.                         {  
90.                             v=pre[u];  
91.                             int w=match[v];  
92.                             match[u]=v;  
93.                             match[v]=u;  
94.                             u=w;  
95.                         }  
96.                         return true;  
97.                     }  
98.                 }  
99.             }  
100.         }  
101.     }  
102.     return false;  
103. }  
104.    
105. int solve(int n)  
106. {  
107.     SET(match,-1);  
108.     int ans=0;  
109.     for(int i=1;i<=n;i++)  
110.         if(match[i]==-1&&dfs(i,n))  
111.             ans++;  
112.     return ans;  
113. }