hdu 2389 Rain on your Parade

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

　　Hopcroft-Karp算法是二分匹配的一个十分快捷的算法，相对于匈牙利算法在时间上有了相当大的改进！

　　hdu 2389 这题我是前两天尝试做二分匹配的题的时候遇见的，当时我看到点的规模达到3000个，我就想到这题不能用匈牙利算法来过。不过当时我还不会hk算法，所以我只好当作练习匈牙利算法，打了一遍交上去！回来的结果必然是TLE。然后，我只好看了一下题解，才发现hk算法这神级速度的二分匹配算法！

　　我想说一下的是，在图论的算法中，用的最多的优化方式就是将dfs转化成bfs，用队列，优先队列，亦或是单调队列来加快算法的工作速度。

　　这题如果是用dfs，那么搜n个点，e条边，最高的复杂度可以达到O(n^3)。其中的原因是搜索n个点可能出现每次都要搜索大量的边，然而，这些被搜索的边很多都是没必要的。于是，在匈牙利算法的基础上，在dfs前用bfs的方法来预留可能匹配的边，然后dfs搜索的时候就可以减少不必要的搜索，从而加快搜索速度！

代码如下（8.16修改）：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>

using namespace std;
const int maxn = 3001;

int dx[maxn], dy[maxn], mx[maxn], my[maxn];
int q[maxn << 1], qh, qt;
vector<int> rel[maxn];
struct point{
    int x, y;
    int v;
}guest[maxn];

int bfs(int n, int m){
    bool ret = false;

    qh = qt = 0;
    for (int i = 1; i <= m; i++){
        dy[i] = 0;
    }
    for (int i = 1; i <= n; i++){
        dx[i] = 0;
        if (mx[i] == -1){
            q[qt++] = i;
        }
    } // reset status of x&y-set using array dx & dy and queue-in the x-nodes which are not matched

    while (qh != qt){ // set distance of every pair of x,y-nodes
        int cur = q[qh++];

        for (int i = 0; i < rel[cur].size(); i++){
            int t = rel[cur][i];

            if (!dy[t]){
                dy[t] = dx[cur] + 1;
                if (my[t] == -1){
                    ret = true;
                }
                else{
                    dx[my[t]] = dy[t] + 1;
                    q[qt++] = my[t]; // 前一个版本将my[t]写成t水过去了
                } // if t is matched, let the x-node matched with t queue-in and find its other adjacent y-nodes
            }
        }
    }

    return ret;
}

bool dfs(int cur){
    for (int i = 0; i < rel[cur].size(); i++){
        int t = rel[cur][i];

        if (dy[t] == dx[cur] + 1){ // if satisfied the pair distance, go deeper
            dy[t] = 0;
            if (my[t] == -1 || dfs(my[t])){
                my[t] = cur;
                mx[cur] = t;

                return true;
            } // find a satisfied pair
        }
    }

    return false;
}

int hk(int n, int m){
    int cnt = 0;

    for (int i = 1; i <= n; i++){
        mx[i] = my[i] = -1;
    }
    while (bfs(n, m)){
        for (int i = 1; i <= n; i++){
            if (mx[i] == -1 && dfs(i)){
                cnt++;
            }
        }
    }

    return cnt;
}

bool judge(point g, point u, int t){
    int x = g.x - u.x;
    int y = g.y - u.y;
    int s = g.v * t;

    if (x * x + y * y <= s * s){
        return true;
    }

    return false;
}

void deal(int c){
    int n, m, t;

    scanf("%d", &t);
    scanf("%d", &n);
    for (int i = 1; i <= n; i++){
        scanf("%d%d%d", &guest[i].x, &guest[i].y, &guest[i].v);
        rel[i].clear();
    }
    scanf("%d", &m);
    for (int i = 1; i <= m; i++){
        scanf("%d%d", &guest[0].x, &guest[0].y);
        for (int j = 1; j <= n; j++){
            if (judge(guest[j], guest[0], t)){
                rel[j].push_back(i);
            }
        }
    }

    printf("Scenario #%d:\n%d\n\n", c, hk(n, m));
}

int main(){
    int n;

#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
#endif

    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        deal(i);

    return 0;
}

　　修改内容包括：

1.删除记录入队情况的bool数组，因为元素不会入队两次

2.在hk函数中，dfs前必须判断该边是否已经匹配

hk算法：http://www.cnblogs.com/LyonLys/archive/2012/08/11/Hopcroft_Karp_Lyon.html

 ——written by Lyon