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

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

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

       s
      /  \
     a    b
     |    |
     c    d
    / \  / \
    e f  u j
    | |  | |
    i j  v k
其中,黑色竖线相连的两个点是已经匹配好的,蓝色斜线表示两个点之间有边,但是没有配对。T型的用红色,S型的用黑色。


这里有个小问题:一个S型点d在某一步扩展的时候发现了点u,如果u已经在搜索树上了(即,出现了环),怎么办?
我们规定,如果u的类型是T型,就无视这次发现;(这意味着我们找到了一个长度为偶数的环,直接无视)
       s
      /  \
     a    b
     |    |
     c    d   如果连出来的边是指向T型点的,就无视这个边。
    / \  / \
    e f<-  
    | |    |
    i j    k
否则,我们找到了一个长度为奇数的环,就要进行一次“缩花”的操作!所谓缩花操作,就是把这个环缩成一个点。
       s
      /  \
     a    b
     |    |
     c    d
    / \  / \
    e f   
    | |   |
    i u<-+ k
这个图缩花之后变成了5个点(一个大点,或者叫一朵花,加原来的4个点):
缩点完成之后,还要把原来环里面的T型点统统变成S型点,之后扔到队列里去。
  +-------------+
  |             |
  |     s       |
  |    /  \     |
  |   a    b    |
  |   |    |    |   现在是一个点了!还是一个S点。
  |   c    d    |
  |  / \  / \   |
+---  f--u  ------+
| |             |   
 |             |   
 |             |   
 +-------------+   
                   
e                   g
|                   |
i                   k
为什么能缩成一个点呢?我们看一个长度为奇数的环(例如上图中的s-b-d-j-f-c-a-),如果我们能够给它中的任意一个点找一个出度(配偶),那么环中的其他点正好可以配成对,这说明,每个点的出度都是等效的。例如,假设我们能够给图中的点d另找一个配偶(例如d'好了),那么,环中的剩下6个点正好能配成3对,一个不多,一个不少(算上d和d'一共4对刚刚好)。
b-dd'         a s-b d-d'
 \           =>    \     
  cf-u              c f-u
这就是我们缩点的思想来源。有一个劳苦功高的计算机科学家证明了:缩点之前和缩点之后的图是否有增广路的情况是相同的。
缩起来的点又叫一朵花(blossom).
注意到,组成一朵花的里面可能嵌套着更小的花。


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


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


Next数组很奇妙。每时每刻,它实际形成了若干个挂在一起的双向链表来表示一朵花内部的走法。
     ----
    /    \--+
    |    |   |
    |    |--+
    v    v
   ----------
  /          \
+-            --+
|               |
|               |

+----s  ------+


然后就在网上找找看有没有神马模板代码之类的,在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. }  

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值