HDU 2063

题目连接：过山车

一道二分图的模板题，题目比较简单，适合当做模板。

这里总结一下这道题用到的方法。

 

1） 二分图匈牙利算法。

     匈牙利算法应该算是解二分图的基本方法了。

2）网络流.

    用网络流来解二分图，感觉贼爽，最大匹配就是最大流....

    不过，有不少题目会卡网络流！

    网络流相关知识点请移步：网络流与二分图

   上面两种思路的代码请移步：过山车

3）KM 。     

    没学过 KM 算法....据说是匈牙利算法的优化。

4）HK

   本文主要介绍的就是 HK 算法。学习 HK 的初衷是发现很多题目不但卡网络流，甚至还卡匈牙利，更有甚者，连KM（dfs)一起卡了。具体题目请移步：HDU 2389

关于HK的讲解：

转载于：https://blog.csdn.net/wall_f/article/details/8248373

 

Hopcroft-Karp算法

该算法由John.E.Hopcroft和Richard M.Karp于1973提出，故称Hopcroft-Karp算法。

原理

为了降低时间复杂度，可以在增广匹配集合M时，每次寻找多条增广路径。这样就可以进一步降低时间复杂度，可以证明，算法的时间复杂度可以到达O（n^0.5*m），虽然优化不了多少，但在实际应用时，效果还是很明显的。

基本算法

该算法主要是对匈牙利算法的优化，在寻找增广路径的时候同时寻找多条不相交的增广路径，形成极大增广路径集，然后对极大增广路径集进行增广。在寻找增广路径集的每个阶段，找到的增广路径集都具有相同的长度，且随着算法的进行，增广路径的长度不断的扩大。可以证明，最多增广n^0.5次就可以得到最大匹配。

算法流程

（1）从G=(X,Y;E)中取一个初始匹配。

（2）若X中的所有顶点都被M匹配，则表明M为一个完美匹配，返回；否则，以所有未匹配顶点为源点进行一次BFS，标记各个点到源点的距离。

（3）在满足dis[v] = dis[u] + 1的边集<v,u>中，从X中找到一个未被M匹配的顶点x0，记S = {x0}，T = ￠。

（4）若N（S） = T，则表明当前已经无法得到更大匹配，返回；否则取一y0∈N(S) - 。

（5）若y0已经被M匹配则转步骤（6），否则做一条x0->y0的M-增广路径P（x0,y0）,取M = M△P（x0,y0）。

（6）由于y已经被M匹配，所以M中存在一条边（y0,z0）去S = S∪ {z0}，T = T∪{y0}，转步骤（2）。

算法具体时间与分析

在寻找增广路径中可以对X中的每个未匹配的顶点进行BFS，BFS时对每个顶点维护一个距离编号dx[nx],dy[ny]，如果某个Y中的节点为未匹配点，则找到一条增广路径。BFS结束后找到了增广路径集。然后利用DFS与匈牙利算法类似的方法对每条增广路进行增广，这样就可以找到最大匹配。

 

过山车代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
const int maxn = 50100;
const int maxm = 151000;
const int INF = 2147483646;

struct Node{
	int to;
	int ne;
}e[maxm];

int nx,ny;//左边顶点数量，右边顶点数量
int cnt;
int head[maxn];
int xlink[maxn],ylink[maxn];
    /*
    xlink[i]表示左集合顶点所匹配的右集合顶点序号
    ylink[i]表示右集合i顶点匹配到的左集合顶点序号。
    */
int disx[maxn],disy[maxn];
    /*
    disx[i]表示左集合i顶点的距离编号
    disy[i]表示右集合i顶点的距离编号
    */
queue<int>q;
int ans;

void init(){
	memset(xlink,-1,sizeof(xlink));
	memset(ylink,-1,sizeof(ylink));
	memset(head,-1,sizeof(head));
	cnt = ans = 0; 
	while(!q.empty()){
		q.pop();
	}
} 

void add(int u,int v){
	e[cnt].to = v;
	e[cnt].ne = head[u];
	head[u] = cnt ++;
}

bool bfs(){
	bool flag = 0;
	memset(disx,0,sizeof(disx));
	memset(disy,0,sizeof(disy));
	for(int i=1;i<=nx;i++){
		if(xlink[i] == -1){
			q.push(i);
		}
	}
	while(!q.empty()){
		int now = q.front();
		for(int i=head[now];~i;i=e[i].ne){
			int to = e[i].to;
			if(!disy[to]){
				disy[to] = disx[now] + 1;
				if(ylink[to] == -1) flag = 1;
				else {
					disx[ylink[to]] = disy[to] + 1;
					q.push(ylink[to]);
				}
			}
		}
		q.pop();
	}
	return flag;
}

bool dfs(int u){
	for(int i = head[u];~i;i=e[i].ne){
		int to = e[i].to;
		if(disy[to] == disx[u] + 1){
			disy[to] = 0;
			if(ylink[to] == -1 || dfs(ylink[to])){
				xlink[u] = to;
				ylink[to] = u;
				return 1;
			}
		}
	}
	return 0;
}

void HK(){
	while(bfs()){
		for(int i=1;i<=nx;i++){
			if(xlink[i] == -1 && dfs(i)){
				++ans;
			}
		}
	}
}

int main()
{
	int k;
	while(scanf("%d",&k) && k){
		init();
		scanf("%d%d",&nx,&ny);
		for(int i=1;i<=k;i++){
			int a,b;
			scanf("%d%d",&a,&b);
			add(a,b);
		}
		HK();
		printf("%d\n",ans);
	}
	return 0;
}