HDU 2389 Rain on your Parade（Hopcroft-Karp）

Problem Description

You’re giving a party in the garden of your villa by the sea. The party is a huge success, and everyone is here. It’s a warm, sunny evening, and a soothing wind sends fresh, salty air from the sea. The evening is progressing just as you had imagined. It could be the perfect end of a beautiful day.
But nothing ever is perfect. One of your guests works in weather forecasting. He suddenly yells, “I know that breeze! It means its going to rain heavily in just a few minutes!” Your guests all wear their best dresses and really would not like to get wet, hence they stand terrified when hearing the bad news.
You have prepared a few umbrellas which can protect a few of your guests. The umbrellas are small, and since your guests are all slightly snobbish, no guest will share an umbrella with other guests. The umbrellas are spread across your (gigantic) garden, just like your guests. To complicate matters even more, some of your guests can’t run as fast as the others.
Can you help your guests so that as many as possible find an umbrella before it starts to pour?
Given the positions and speeds of all your guests, the positions of the umbrellas, and the time until it starts to rain, find out how many of your guests can at most reach an umbrella. Two guests do not want to share an umbrella, however.

Input

The input starts with a line containing a single integer, the number of test cases.
Each test case starts with a line containing the time t in minutes until it will start to rain (1 <=t <= 5). The next line contains the number of guests m (1 <= m <= 3000), followed by m lines containing x- and y-coordinates as well as the speed si in units per minute (1 <= si <= 3000) of the guest as integers, separated by spaces. After the guests, a single line contains n (1 <= n <= 3000), the number of umbrellas, followed by n lines containing the integer coordinates of each umbrella, separated by a space.
The absolute value of all coordinates is less than 10000.

Output

For each test case, write a line containing “Scenario #i:”, where i is the number of the test case starting at 1. Then, write a single line that contains the number of guests that can at most reach an umbrella before it starts to rain. Terminate every test case with a blank line.

Sample Input

2
1
2
1 0 3
3 0 3
2
4 0
6 0
1
2
1 1 2
3 3 2
2
2 2
4 4

Sample Output

Scenario #1:
2
Scenario #2:
2

---

思路

3000*3000图用匈牙利算法果然t了，关于Hopcroft-Karp算法，网上没找什么好的中文资料（流下了弱者的眼泪，于是看着代码硬啃，可能会有一些理解上的不到位，只敢随便口胡一点。
Hopcroft-Karp算法， 同时寻找多条增广路，用bfs来搜索增广路是否存在并且标记搜索顺序。用递归来更新匹配方案。

代码

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<queue>
using namespace std;

int t, m, n;
int first[3005], tot;

struct Node
{
    int x, y, s;
}data[3005];

struct Edge
{
    int v, next;
}e[9000005];

void add(int u, int v)
{
    e[tot].v = v;
    e[tot].next = first[u];
    first[u] = tot++;
}

bool judge(int x, int y, int j)
{
    if( sqrt( 1.0*(x - data[j].x)*(x - data[j].x) + 1.0*(y - data[j].y)*(y - data[j].y) ) / (1.0*data[j].s) <= 1.0*t ) return 1;
    return 0;
}

// nxt代表如何连接 x为左，y为右
int usedx[3005], usedy[3005], nxtx[3005], nxty[3005], dis;
bool vis[3005];

bool searchpath()
{
    queue<int> q;
    dis = 0x3f3f3f3f;
    memset(usedx,-1,sizeof(usedx)); // 记录某点据0点距离
    memset(usedy,-1,sizeof(usedy));
    for(int i = 1; i <= n; i++) if(nxtx[i] == -1) q.push(i), usedx[i] = 0; // 将左边未匹配点距离设为0，入队

    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        if(usedx[u] > dis) break; // 这条不明效果 提前结束？ 注释了效率好像低了一些

        for(int i = first[u]; ~i; i = e[i].next)
        {
            int v = e[i].v;
            if(usedy[v] == -1) // 右边该点可到达且未被刷新距离
            {
                usedy[v] = usedx[u]+1; // 更新距离
                if(nxty[v] == -1) dis = usedy[v]; // 如果右边该点未被匹配则找到增广路
                else // 否则找到右边该点的匹配点更新其距离并入队
                {
                    usedx[nxty[v]] = usedy[v]+1;
                    q.push(nxty[v]);
                }
            }
        }
    }
    return dis != 0x3f3f3f3f; // 不为正无穷则找到路径
}

bool find(int u)
{
    for(int i = first[u]; ~i; i = e[i].next)
    {
        int v = e[i].v;
        if(!vis[v] && usedy[v] == usedx[u] + 1) // 右边点能到达 且 递归过程中不重复到达 且 可能是该点增广路
        {
            vis[v] = 1; // 标记
            if(~nxty[v] && usedy[v] == dis) continue; // 如果右边该点已匹配 且 为路的末端
            if(nxty[v] == -1 || find(nxty[v])) // 右边该点未匹配 或者 能使匹配右边该点的左边的点找到新的右边的点
            {
                nxtx[u]  = v;
                nxty[v] = u;
                return 1;
            }
        }
    }
    return 0;
}

int match()
{
    memset(nxtx,-1,sizeof(nxtx));
    memset(nxty,-1,sizeof(nxty));
    int sum = 0;
    while(searchpath())
    {
        memset(vis,0,sizeof(vis));
        for(int i = 1; i <= n; i++)
        {
            if(nxtx[i] == -1 && find(i)) sum++; // 如果左边该点未匹配且能找到增广路
        }
    }
    return sum;
}

int main()
{
    int TT, cnt = 0;
    scanf("%d",&TT);
    while(TT--)
    {
        scanf("%d%d",&t,&m);
        for(int i = 1; i <= m; i++) scanf("%d%d%d",&data[i].x,&data[i].y,&data[i].s);

        int x, y;
        scanf("%d",&n);
        tot = 0;
        memset(first,-1,sizeof(first));
        for(int i = 1; i <= n; i++)
        {
            scanf("%d%d",&x,&y);
            for(int j = 1; j <= m; j++)
            {
                if(judge(x,y,j)) add(i,j);
            }
        }
        printf("Scenario #%d:\n",++cnt);
        printf("%d\n\n",match());
    }
    return 0;
}