uestc SOUND OF DESTINY

邻接表版的DFS形式的二分匹配

增广路求最大匹配数

 

匈牙利算法的要点如下

1. 从左边第 1 个顶点开始，挑选未匹配点进行搜索，寻找增广路。

   1. 如果经过一个未匹配点，说明寻找成功。更新路径信息，匹配边数 +1，停止搜索。
   2. 如果一直没有找到增广路，则不再从这个点开始搜索。事实上，此时搜索后会形成一棵匈牙利树。我们可以永久性地把它从图中删去，而不影响结果。

2. 由于找到增广路之后需要沿着路径更新匹配，所以我们需要一个结构来记录路径上的点。DFS 版本通过函数调用隐式地使用一个栈，而 BFS 版本使用 prev 数组。

　　详细介绍http://www.renfei.org/blog/bipartite-matching.html

bool 寻找从k出发的对应项出的可增广路

{

    while (从邻接表中列举k能关联到顶点j)

    {

        if (j不在增广路上)

        {

            把j加入增广路;

            if (j是未盖点 或者 从j的对应项出发有可增广路)

            {

                修改j的对应项为k;

                则从k的对应项出有可增广路,返回true;

            }

        }

    }

    则从k的对应项出没有可增广路,返回false;

}



void 匈牙利hungary()

{

    for i->1 to n

    {

        if (则从i的对应项出有可增广路)

            匹配数++;

    }

    输出 匹配数;

}

　　

 1 #include<iostream>

 2 #include<cstdio>

 3 #include<cstdlib>

 4 #include<cstring>

 5 #include<string>

 6 #include<queue>

 7 #include<algorithm>

 8 #include<map>

 9 #include<iomanip>

10 #include<climits>

11 #include<string.h>

12 #include<cmath>

13 #include<stdlib.h>

14 #include<vector>

15 #define INF 1e7

16 #define MAXN 100010

17 #define maxn 1000010

18 #define Mod 1000007

19 #define N 1010

20 using namespace std;

21 typedef long long LL;

22 

23 int n, m, k, a, b, ans;

24 bool vis[N];

25 int match[N];

26 vector<int> G[N];

27 

28 bool Search_path(int src)

29 {

30     for (int i = 0; i < G[src].size(); ++i) { 

31         int v = G[src][i];

32         if (!vis[v]) {　　　　　　　　　　　　　　

33             vis[v] = true;　　　　　　　　　　　　

34             if (match[v] == -1 || Search_path(match[v])) {

35                 match[v] = src;

36                 return true;

37             }

38         }

39     }

40     return false;   　　　　　　　　　　　　　　　　

41 }

42 

43 void init()

44 {

45     ans = 0;

46     for (int i = 0; i <= n; ++i)

47         G[i].clear();

48     memset(match,-1,sizeof(match));

49 }

50 

51 int main()

52 {

53     while (cin >> n >> m) {

54         init();

55         cin >> k;

56         for (int i = 0; i < k; ++i) {

57             cin >> a >> b;

58             a--, b--;

59             G[a].push_back(b);

60         }

61         for (int i = 0; i < n; ++i) {

62             memset(vis,0,sizeof(vis));

63             if (Search_path(i))

64                 ans++;

65         }

66         cout << ans << endl;

67     }

68     return 0;

69 }

 

附上模板

 1 // 顶点、边的编号均从 0 开始

 2 // 邻接表储存

 3 

 4 struct Edge

 5 {

 6     int from;

 7     int to;

 8     int weight;

 9 

10     Edge(int f, int t, int w):from(f), to(t), weight(w) {}

11 };

12 

13 vector<int> G[__maxNodes]; /* G[i] 存储顶点 i 出发的边的编号 */

14 vector<Edge> edges;

15 typedef vector<int>::iterator iterator_t;

16 int num_nodes;

17 int num_left;

18 int num_right;

19 int num_edges;

DS

 1 queue<int> Q;

 2 int prev[__maxNodes];

 3 int Hungarian()

 4 {

 5     int ans = 0;

 6     memset(matching, -1, sizeof(matching));

 7     memset(check, -1, sizeof(check));

 8     for (int i=0; i<num_left; ++i) {

 9         if (matching[i] == -1) {

10             while (!Q.empty()) Q.pop();

11             Q.push(i);

12             prev[i] = -1; // 设 i 为路径起点

13             bool flag = false; // 尚未找到增广路

14             while (!Q.empty() && !flag) {

15                 int u = Q.front();

16                 for (iterator_t ix = G[u].begin(); ix != G[u].end() && !flag; ++ix) {

17                     int v = edges[*ix].to;

18                     if (check[v] != i) {

19                         check[v] = i;

20                         Q.push(matching[v]);

21                         if (matching[v] >= 0) { // 此点为匹配点

22                             prev[matching[v]] = u;

23                         } else { // 找到未匹配点，交替路变为增广路

24                             flag = true;

25                             int d=u, e=v;

26                             while (d != -1) {

27                                 int t = matching[d];

28                                 matching[d] = e;

29                                 matching[e] = d;

30                                 d = prev[d];

31                                 e = t;

32                             }

33                         }

34                     }

35                 }

36                 Q.pop();

37             }

38             if (matching[i] != -1) ++ans;

39         }

40     }

41     return ans;

42 }

BFS

 1 int matching[__maxNodes]; /* 存储求解结果 */

 2 int check[__maxNodes];

 3 

 4 bool dfs(int u)

 5 {

 6     for (iterator_t i = G[u].begin(); i != G[u].end(); ++i) { // 对 u 的每个邻接点

 7         int v = edges[*i].to;

 8         if (!check[v]) {     // 要求不在交替路中

 9             check[v] = true; // 放入交替路

10             if (matching[v] == -1 || dfs(matching[v])) {

11                 // 如果是未盖点，说明交替路为增广路，则交换路径，并返回成功

12                 matching[v] = u;

13                 matching[u] = v;

14                 return true;

15             }

16         }

17     }

18     return false; // 不存在增广路，返回失败

19 }

20 

21 int hungarian()

22 {

23     int ans = 0;

24     memset(matching, -1, sizeof(matching));

25     for (int u=0; u < num_left; ++u) {

26         if (matching[u] == -1) {

27             memset(check, 0, sizeof(check));

28             if (dfs(u))

29                 ++ans;

30         }

31     }

32     return ans;

33 }

DFS