HDU2389_Rain on your Parade_二分图匹配::Hopcroft-Carp模板题

题意

给出 N 个人和 M 把伞坐标，并给出每个人的移动速度。T 秒后开始下雨，每个人只能用一把伞。问最多有多少个人能不被雨淋。

思路

显然是二分图匹配，套上匈牙利算法就 T 成狗了。对于大数据的二分图匹配问题应用 Hopcroft-Carp算法。比较匈牙利的 n * e， 它的复杂度是 n^0.5 * e。
但是这个算法比较坑。网上能搜到一大把模板但很少有解析。有这方面的原因吧，到现在也还只是一知半解的状态。默写了一遍 kuangbin 的模板，把题目 AC 掉了。

Hopcroft-Carp算法

匈牙利算法的优化。
匈牙利算法每一次增广是找出了一条增广路，而 HC 算法的基本思想是通过 BFS，找到多条互不相交且长度相同（剩余增广路的最小长度）的增广路，再沿这些增广路做匹配（此处还有点不清晰）。是一种限制最短路长度逐层寻找最短路的方法（也有点模糊）。
感觉这个算法和匈牙利算法明显不同的一点是，在这个算法中，二分图里的两类点是分开的。建图时的边也可以建成有向的（从 A 类点到 B 类点）。

算法过程

1. 把未匹配的 A 类点加入队列，距离置为 0。然后进行bfs。
2. 从队列中取出一个点，沿着它的边探索周围点（当然全是 B 类），当然要首先要更新它们的距离。
3. 然后，如果这个 B 类点还没有匹配，那么我们就找到了一条增广路。把 Dis 更新为这个B 类点距离，本次 bfs 找到的增广路都将是这个长度。
   （为什么不会更小？因为队列中点的距离是递增的，后面的距离只能大于或等于它）
4. 如果这个 B 类点已经匹配过了，那么更新它的匹配点（另一个 A 类点）的距离，并把它加入队列（试图为他寻找新的匹配点）。
   （这里的”另一个A 类的距离在这之前是初始化得来的 -1，因为它必定是在之前某轮的增广中被匹配成功的，所以这一轮一开始它并没有被加入队列）。
5. 按照本步骤不断取点搜索直到队列为空，或者另一种情况发生：
   每一轮 bfs 寻找增广路过程的开始，Dis 被初始化为 inf。而找到一条增广路后，Dis 就会被更新为这条增广路的长度（上面提到过了）。这一轮找到的增广路都应该是这个长度。所以，从队列中取出的 A 类点，如果距离已经大于 Dis 了，就不需要对它的周围进行探索了。又因为队列中点的距离是单调的，所以后面的也都会大于 Dis，所以此处（表现在代码中是对周围进行探索之前）直接 break 就可以了。
6. 寻找增广路过程结束时，判断一下 Dis 是不是等于 inf。如果是，说明这一轮并没有找到新的增广路，表示图中已经没有新的增广路了。前一级函数可以返回 res 了。否则，就要沿着这一轮找到的增广路，把点匹配好，然后再进行 bfs 寻找增广路。

7. 寻找增广路结束后，就要用 dfs 沿着刚找到的增广路把匹配好。与匈牙利算法中的 dfs 只有两行不同（具体见AC代码部分）。

   题目链接

   http://acm.hdu.edu.cn/showproblem.php?pid=2389

   AC代码

#include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>
#include<queue>

using namespace std;

const int maxn = 3000 + 30;
const int  inf = 0x3f3f3f3f;

int Cas, T;
int Ax[maxn], Ay[maxn], Av[maxn];
int Bx[maxn], By[maxn];

/***************************Hopcroft-Carp模板***************************/

int N, M;                                           //两类点的个数
vector<int> G[maxn];
int Mx[maxn], My[maxn];                             //匹配的点
int Dx[maxn], Dy[maxn];                             //bfs寻找增广路时的距离
bool Vis[maxn];                                     //沿增广路匹配时的访问标记
int Dis;                                            //bfs寻找增广路时的距离限制

bool search_path()                                  //bfs寻找增广路
{
    memset(Dx, -1, sizeof Dx);                      //初始化距离
    memset(Dy, -1, sizeof Dy);
    queue<int> qu;
    Dis = inf;                                      //初始化距离限制

    for(int i= 1; i<= N; i++)                       //把没有匹配的A类点加入队列，同时将距离初始化为0
        if(Mx[i] < 0)
        {
            Dx[i] = 0;
            qu.push(i);
        }

    while(qu.size())
    {
        int u = qu.front();
        qu.pop();

        if(Dx[u] > Dis) break;                      //距离超过了限制，再找下去距离也不会变小，所以停止寻找增广路

        for(int i= 0; i< G[u].size(); i++)          //遍历点上的每条边
        {
            int v = G[u][i];

            if(Dy[v] < 0)                           //终点在这次寻找中还未被发现
            {
                Dy[v] = Dx[u] + 1;                  //更新距离

                if(My[v] < 0) Dis = Dy[v];          //该点未匹配，则此时的距离就是此次要寻找的增广路的长度
                else{                               //该点已经匹配了，试着给它的匹配点寻找其他匹配
                    Dx[My[v]] = Dy[v] + 1;
                    qu.push(My[v]);                 //把匹配点加入队列
                }
            }
        }
    }

    return Dis != inf;                              //是否找到了新的增广路
}

bool dfs(int u)                                     //沿着增广路匹配点
{
    for(int i= 0; i< G[u].size(); i++)
    {
        int v = G[u][i];

        if(!Vis[v] && Dy[v] == Dx[u] + 1)           //此次匹配中没有访问过该点，并且这条边在新发现的增广路中
        {
            Vis[v] = true;                          //访问标记

            if(My[v] > 0 && Dy[v] == Dis) continue; //终点已经标记，且此时的距离已经达到距离限制
                                                    //表示它的已有匹配点在本次增广中没有新匹配
            if(My[v] < 0 || dfs(My[v]))
            {
                My[v] = u;
                Mx[u] = v;
                return true;
            }
        }
    }

    return false;
}

int max_match()
{
    int res = 0;                                    //三项初始化
    memset(Mx, -1, sizeof Mx);
    memset(My, -1, sizeof My);

    while(search_path())                            //寻找增广路
    {
        memset(Vis, false, sizeof Vis);             //初始化访问标记

        for(int i= 1; i<= N; i++)                   //沿增广路进行匹配
            if(Mx[i] < 0 && dfs(i)) res ++;
    }

    return res;
}

/***************************Hopcroft-Carp模板***************************/

bool dist(int a, int b)
{
    int d1 = T * Av[a];
    int d2 = (Ax[a] - Bx[b]) * (Ax[a] - Bx[b]) + (Ay[a] - By[b]) *  (Ay[a] - By[b]);
    return d1 * d1 >= d2;
}

int main()
{
    scanf("%d", &Cas);
    for(int cas= 1; cas<= Cas; cas ++)
    {
        scanf("%d %d", &T, &N);
        for(int i= 1; i<= N; i++)
            scanf("%d %d %d", Ax+i, Ay+i, Av+i);

        scanf("%d", &M);
            for(int i= 1; i<= M; i++)
                scanf("%d %d", Bx+i, By+i);

        for(int i= 1; i<= N; i++) G[i].clear();

        for(int i= 1; i<= N; i++)
            for(int j= 1; j<= M; j++)
            if(dist(i, j)) G[i].push_back(j);

        printf("Scenario #%d:\n%d\n\n", cas, max_match());
    }

    return 0;
}