SPOJ 4206 Fast Maximum Matching (二分图最大匹配 Hopcroft-Carp 算法 模板)

题目大意：

有n1头公牛和n2头母牛，给出公母之间的m对配对关系，求最大匹配数。数据范围：  1 <= n1, n2 <= 50000, m <= 150000

算法讨论：

第一反应KM直接上，第二反应，KM是O(N^2 * M)的，会T成狗。

第二反应，看看大家是怎么做的。后来发现了一个名字叫 Hopcroft-Carp的二分图最大匹配的算法。可以在O(sqrt(n) * m)的时间内解决二分图的最大匹配问题。非常适合大数据的二分图匹配。所以就学习了一下。 我们知道，普通的匈牙利慢的原因是因为他一次深搜只找一条增广路，而HC算法是利用Bfs同时找多条增广路。

下面有网友提供的HC算法的原理：

SRbGa很早就介绍过这个算法，它可以做到O(sqrt(n)*e)的时间复杂度，并且在实际使用中效果不错而且算法本身并不复杂。

Hopcroft-Karp算法是Hopcroft和Karp在1972年提出的，该算法的主要思想是在每次增广的时候不是找一条增广路而是同时找几条不相交的最短增广路，形成极大增广路集，随后可以沿着这几条增广路同时进行增广。

可以证明在寻找增广路集的每一个阶段所寻找到的最短增广路都具有相等的长度，并且随着算法的进行最短增广路的长度是越来越长的，更进一步的分析可以证明最多只需要增广ceil(sqrt(n))次就可以得到最大匹配（证明在这里略去）。

因此现在的主要难度就是在O(e)的时间复杂度内找到极大最短增广路集，思路并不复杂，首先从所有X的未盖点进行BFS，BFS之后对每个X节点和Y节点 维护距离标号，如果Y节点是未盖点那么就找到了一条最短增广路，BFS完之后就找到了最短增广路集，随后可以直接用DFS对所有允许弧 (dist[y]=dist[x]+1，可以参见高流推进HLPP的实现)进行类似于匈牙利中寻找增广路的操作，这样就可以做到O(m)的复杂度。

实现起来也并不复杂，对于两边各50000个点，200000条边的二分图最大匹配可以在1s内出解~~

那么此题就可以用HC算法轻松跑过。提醒，一定要注意常数。SPOJ跑得太慢了。

果然我的常数是很大。。。。。。

Codes：

 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <iostream>
 #include <algorithm>
 using namespace std;

 struct Hopcroft_Carp{
     static const int N =  + ;
     static const int M =  + ;
     static const int oo = 0x3f3f3f3f;

     int n1, n2, res, tot;
     int dsx[N], dsy[N], mx[N], my[N];
     int que[N<<];bool vi[N<<];
     int first[N<<], next[M];
     int u[M], v[M];

     void Clear(){tot = ; res = ;}
     void Add(int from, int to){
         ++ tot;
         u[tot] = from; v[tot] = to;
         next[tot] = first[u[tot]];
         first[u[tot]] = tot;
     }

     bool bfs(){
         for(int i = ; i <= n1; ++ i) dsx[i] = -;
         for(int i = ; i <= n2; ++ i) dsy[i] = -;
         res = oo;

         int head, tail;
         head = tail = ;
         for(int i = ; i <= n1; ++ i)
             if(mx[i] == -) que[++ tail] = i, dsx[i] = ;
         while(head <= tail){
             int x = que[head];
             if(dsx[x] > res) break;

             for(int i = first[x]; i; i = next[i]){
                 if(dsy[v[i]] == -){
                     dsy[v[i]] = dsx[x] + ;
                     if(my[v[i]] == -) res = dsy[v[i]];
                     else{
                         dsx[my[v[i]]] = dsy[v[i]] + ;
                         que[++ tail] = my[v[i]];
                     }
                 }
             }
             ++ head;
         }
         return res != oo;
     }

     bool dfs(int x){
         for(int i = first[x]; i; i = next[i]){
             if(!vi[v[i]] && dsy[v[i]] == dsx[x] + ){
                 vi[v[i]] =  true;
                 if(my[v[i]] != - && dsy[v[i]] == res) continue;
                 if(my[v[i]] == - || dfs(my[v[i]])){
                     my[v[i]] = x;
                     mx[x] = v[i];
                     return true;
                 }
             }
         }
         return false;
     }

     int MaxMatch(){
         int ans = ;
         for(int i = ; i <= n1; ++ i) mx[i] = -;
         for(int i = ; i <= n2; ++ i) my[i] = -;

         while(bfs()){
             for(int i = ; i <= n1+n2; ++ i) vi[i] = false;
             for(int i = ; i <= n1; ++ i)
                 if(mx[i] == - && dfs(i)) ans ++;
         }
         return ans;
     }
 }Two;

 int n1, n2, m;

 int main(){
     int x, y;
     scanf("%d%d%d", &n1, &n2, &m);
     Two.Clear();
     Two.n1 = n1; Two.n2 = n2;
     for(int i = ; i <= m; ++ i){
         scanf("%d%d", &x, &y);
         Two.Add(x, y);
     }
     printf("%d\n", Two.MaxMatch());
     return ;
 }

SPOJ 4206