二分图 匈牙利 算法 （模版）

以前就做过 二分图，在另一个 博客 里 ，现在 搬过来 了。。

 

这里求的是最大匹配

匈牙利算法的基本知识：

百度百科：

http://baike.baidu.com/view/501092.htm

 

维基百科： 这里面有邻接矩阵的模拟图

http://en.wikipedia.org/wiki/Hungarian_algorithm

二分图定理总结

原文地址

========

对于任意图：

|最小边覆盖|+|最大匹配|=|V|

二分图的最大匹配=最小点覆盖数

对于二分图：

以下数值等价.

最大匹配

最小点覆盖

|V|-最大独立集(二分图or有向无环图)

|V|-最小边覆盖数

|V|-最小路径覆盖数(有向无环图)

|V|-最小路径覆盖数/2(无向图)

（上面括号里有有向无环图的，均是将一个点拆成两个点连边匹配）

由于任意图的那几个几乎用不到于是这里只贴二分图的定义

最小点覆盖：理解为点覆盖边，即用最小的点覆盖所有的边。(若一条边的其中一个端点被选用，这条边就被覆盖了)

最大独立集：求一个最大的点集，里面的点不存在任何的边相连。

最小边覆盖：理解为边覆盖点，用最少的边把图中的点全部覆盖。

最小路径覆盖：用最少的路径把图中的所有点覆盖。

 

 

另外：最大独立集与最小覆盖集互补。

 

推广到有权的形式也一样,即最大点权独立集与最小点权覆盖集互补

求最小点权覆盖集可以这样求：

先对图黑白染色，然后向白色的点放X部，黑色的点放Y部。

1、连边[S,i],容量等于i的点权。（对于二分图的X集）

2、连边[i,T],容量等于i的点权。（对于二分图的Y集）

3、对于有边的i和j连边[i,j]（i∈X，j∈Y）,容量为INF

最后得出的最大流就是最小点权覆盖，实际上是最小割与之对应。

 

对于求了传递闭包以后的有向无环图：

最大反链=|V|-最大匹配

 

 1 #include <stdio.h>
 2 
 3 #include < string.h>
 4 
 5  int n1, n2, m, ans;
 6 
 7  int result[ 101];  // 记录V2中的点匹配的点的编号
 8  bool state [ 101];  // 记录V2中的每个点是否被搜索过
 9  bool data[ 101][ 101]; // 邻接矩阵 true代表有边相连
10  void init()
11 
12 {
13 
14      int t1, t2;
15 
16     memset(data,  0,  sizeof(data));
17 
18     memset(result,  0,  sizeof(result));
19 
20     ans =  0;
21 
22     scanf( " %d%d%d ", &n1, &n2, &m);
23 
24      for ( int i =  1; i <= m; i++)
25 
26     {
27 
28      scanf( " %d%d ", &t1, &t2);k
29 
30      data[t1][t2] =  true;
31 
32     }
33 
34      return;
35 
36 }
37 
38  bool find( int a)
39 
40 {
41 
42      for ( int i =  1; i <= n2; i++)
43 
44     {
45 
46         if (data[a][i] ==  1 && !state[i])  // 如果节点i与a相邻并且未被查找过
47          {
48 
49           state[i] =  true;  // 标记i为已查找过
50             if (result[i] ==  0  // 如果i未在前一个匹配M中
51            || find(result[i]))  // i在匹配M中，但是从与i相邻的节点出发可以有增广路
52            {
53 
54             result[i] = a;  // 记录查找成功记录
55               return  true;  // 返回查找成功
56            }
57 
58          }
59 
60     }
61 
62      return  false;
63 
64 }
65 
66  int main()
67 
68 {
69 
70     init();
71 
72      for ( int i =  1; i <= n1; i++)
73 
74     {
75 
76        memset(state,  0,  sizeof(state));  // 清空上次搜索时的标记
77          if (find(i)) ans++;  // 从节点i尝试扩展（每一次增加一条边 或一个顶点）
78      }
79 
80     printf( " %d\n ", ans);
81 
82  return  0;
83 
84 }

 

邻接表：

 1 #include<cstdio>
 2 #include<cstring>
 3 #include<cmath>
 4 #include<iostream>
 5 #include<algorithm>
 6 #include< set>
 7 #include<map>
 8 #include<queue>
 9 #include<vector>
10 #include< string>
11  #define Min(a,b) a<b?a:b
12  #define Max(a,b) a>b?a:b
13  #define CL(a,num) memset(a,num,sizeof(a));
14  #define eps  1e-6
15  #define inf 10001000
16 
17  #define ll   __int64
18 
19  #define  read()  freopen("data.txt","r",stdin) ;
20  const  double pi  = acos(- 1.0);
21  const  int maxn =  200;
22 
23  using  namespace std;
24  int n,m;
25  int head[maxn] ;
26  int result[maxn],vis[maxn] ;
27  struct node
28 {
29      int v;
30      int next;
31 }p[maxn*maxn];
32  int cnt ;
33  void add( int u, int v)
34 {
35     p[cnt].v = v;
36     p[cnt].next = head[u];
37     head[u] = cnt++ ;
38 }
39  bool find( int u)
40 {
41 
42      for( int i = head[u];i!= - 1;i = p[i].next)
43     {
44          int v = p[i].v ;
45          if(!vis[v])
46         {
47             vis[v] =  1 ;
48              if(result[v] == - 1||find(result[v]))
49             {
50                 result[v] = u;
51                  return  true;
52             }
53         }
54     }
55      return  false ;
56 }
57  int  get()
58 {
59      int ans=  0;
60     CL(result,- 1);
61      for( int i =  1;i <= n;i++)
62     {
63         CL(vis, 0);
64          if(find(i))ans++;
65     }
66      return ans ;
67 }
68  int main()
69 {
70      // read() ;
71       int t ,i,x,y;
72     scanf( " %d ",&t);
73      while(t--)
74     {
75         cnt =  0;
76         CL(head,- 1) ;
77         scanf( " %d%d ",&n,&m);
78          for(i =  0 ; i < m;i++)
79         {
80             scanf( " %d%d ",&x,&y);
81             add(x,y);
82         }
83          int ans =  get() ;
84         printf( " %d\n ",n - ans) ;
85     }
86 }