匈牙利算法求最大匹配（DFS、BFS实现）

求解最大匹配问题的一个算法是匈牙利算法。

交替路：从一个未匹配点出发，依次经过非匹配边、匹配边、非匹配边…形成的路径叫交替路。

增广路：从一个未匹配点出发，走交替路，如果途径另一个未匹配点（出发的点不算），则这条交替路称为增广路（agumenting path）。例如，图 5 中的一条增广路如图 6 所示（图中的匹配点均用红色标出）：

增广路有一个重要特点：非匹配边比匹配边多一条。因此，研究增广路的意义是改进匹配。只要把增广路中的匹配边和非匹配边的身份交换即可。由于中间的匹配节点不存在其他相连的匹配边，所以这样做不会破坏匹配的性质。交换后，图中的匹配边数目比原来多了 1 条。

我们可以通过不停地找增广路来增加匹配中的匹配边和匹配点。找不到增广路时，达到最大匹配（这是增广路定理）。匈牙利算法正是这么做的。在给出匈牙利算法 DFS 和 BFS 版本的代码之前，先讲一下匈牙利树。

匈牙利树一般由 BFS 构造（类似于 BFS 树）。从一个未匹配点出发运行 BFS（唯一的限制是，必须走交替路），直到不能再扩展为止。例如，由图 7，可以得到如图 8 的一棵 BFS 树：

这棵树存在一个叶子节点为非匹配点（7 号），但是匈牙利树要求所有叶子节点均为匹配点，因此这不是一棵匈牙利树。如果原图中根本不含 7 号节点，那么从 2 号节点出发就会得到一棵匈牙利树。这种情况如图 9 所示（顺便说一句，图 8 中根节点 2 到非匹配叶子节点 7 显然是一条增广路，沿这条增广路扩充后将得到一个完美匹配）。

匈牙利算法的要点如下

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

   1.如果经过一个未匹配点，说明寻找成功。更新路径信息，匹配边数 +1，停止搜索。
   2.如果一直没有找到增广路，则不再从这个点开始搜索。事实上，此时搜索后会形成一棵匈牙利树。我们可以永久性地把它从图中删去，而不影响结果。这是因为，匈牙利树是完整的bfs树，且其中全是匹配点，没有未匹配点，从下一个未匹配点开始bfs时是不会通过匈牙利树的部分路径找到另一个未匹配点的，因此也就不可能通过改变匈牙利树的匹配来进行增广，可以删去。
   3.在dfs版代码中，为什么只要对左边的每一个点的每一个相邻顶点逐个dfs一遍，即可找到所有增广路？因为，增广路的长度一定是奇数，其首尾点一定是分别在两边的，所以只遍历左边就可以。而且，每一次dfs，如果不成功，即找到了一个匈牙利树；如果成功，也是把增广路改成匈牙利树，而匈牙利树是可以不用再管的，不会出现对序号靠后的点dfs后，又新出现以序号靠前的点为起始的增广路。这样对左边每一点的每一个相邻点顺序dfs后，可以保证找出所有的增广路，尽管可能重复找到一些匈牙利树。

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

性能比较

• 两个版本的时间复杂度均为O(V⋅E)。DFS 的优点是思路清晰、代码量少，但是性能不如 BFS。我测试了两种算法的性能。对于稀疏图，BFS版本明显快于 DFS 版本；而对于稠密图两者则不相上下。在完全随机数据 9000 个顶点 4,0000 条边时前者领先后者大约97.6%，9000 个顶点100,0000 条边时前者领先后者 8.6%, 而达到 500,0000 条边时 BFS 仅领先 0.85%。

匈牙利算法DFS板子：
(dfs(match[v])就保证了走的是交替路。注意第一个点不要标记为已用！！）

	static int maxn,match[]=new int[maxn],n,m;//match容量为右边点个数。n为左边点数量，m为右边点数量
	static ArrayList<Integer> G[]=new ArrayList[maxn];
	static boolean used[]=new boolean[maxn];//used容量为右边点个数
//used、match数组都只需要记录右边的点是否已在交替路、其匹配点。观察匈牙利算法即知。
//在main函数中，如果是多例记得初始化G[][]
//点序号从1开始
	static boolean dfs(int u) {
		for(int i=0;i<G[u].size();i++) {
			v=G[u].get(i);
			if(!used[v]) {//要求不在交替路中
				used[v]=true;//放入交替路
				if(match[v]==-1||dfs(match[v])) {
					//是未覆盖点，说明交替路为增广路，交换路径并返回true
					match[v]=u;
					return true;
				}
			}
		}
		return false;
	}
	
	static int hungarian() {
		int ans=0;
		for(int i=1;i<=m;i++) {
			match[i]=-1;
		}
		for(int i=1;i<=n;i++) {
			for(int j=1;j<=m;j++) {
				used[j]=false;
			}
			if(dfs(i)) {
				ans++;
			}
		}
		return ans;
	}

BFS板子(未验证)：

	static int n,left_n,maxn=10010,prev[]=new int[maxn],check[]=new int[maxn],match[]=new int[maxn];
	static Vector<Integer>G[]=new Vector[maxn];
	static int hung() {
		int ans=0;
		for(int i=0;i<n;i++) {
			match[i]=-1;
			check[i]=-1;
		}
		LinkedList<Integer> q=new LinkedList<>();
		for(int i=0;i<left_n;i++) {
			if(match[i]==-1) {
				while(!q.isEmpty())q.poll();
				q.add(i);
				prev[i]=-1;
				boolean flag=false;
				while(!q.isEmpty()&&!flag) {
					int u=q.poll();
					for(int ix=0;ix<G[u].size()&&!flag;ix++) {
						int v=G[u].get(ix);
						if(check[v]!=i) {
							check[v]=i;
							q.add(match[v]);
							if(match[v]>=0) {
								prev[match[v]]=u;
							}else {
								flag=true;
								ans++;
								int d=u,e=v;
								while(d!=-1) {
									int t=match[d];
									match[d]=e;
									match[e]=d;
									d=prev[d];
									e=t;
								}
							}
						}
					}
				}
			}
		}
		return ans;
	}