HDU-2389-Rain on your Parade (最大匹配,kopcroft-karp)

Posted 2022-04-01 ydddd

链接:

https://vjudge.net/problem/HDU-2389

题意:

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.

思路:

二分图最大匹配,匈牙利算法超时。改用hopcroft-karp算法。
吧能在时间内跑到的伞加到人的配对上，hopcroft-karp算法还不是太懂。

代码：

#include <iostream>
#include <cstdio>
#include <vector>
#include <memory.h>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
using namespace std;
const int MAXN = 3e3+10;
const int INF = 1<<30;

struct Node

    double x, y;
;
Node P[MAXN], U[MAXN];
vector<int> G[MAXN];
double Speed[MAXN];
int Link_l[MAXN], Vis[MAXN];
int Link_r[MAXN];
int Dis_x[MAXN], Dis_y[MAXN];
int n, m;
int dis;

double GetLen(Node a, Node b)

    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));


bool Search()

    memset(Dis_x, -1, sizeof(Dis_x));
    memset(Dis_y, -1, sizeof(Dis_y));
    dis = INF;
    queue<int> que;
    for (int i = 1;i <= m;i++)
    
        if (Link_r[i] == -1)
            que.emplace(i);
        Dis_x[i] = 0;
    
    while (!que.empty())
    
        int u = que.front();
        que.pop();
        if (Dis_x[u] > dis)
            break;
        for (int i = 0;i < G[u].size();i++)
        
            int node = G[u][i];
            if (Dis_y[node] == -1)
            
                Dis_y[node] = Dis_x[u]+1;
                if (Link_l[node] == -1)
                    dis = Dis_y[node];
                else
                
                    Dis_x[Link_l[node]] = Dis_y[node]+1;
                    que.push(Link_l[node]);
                
            
        
    
    return dis != INF;


bool Dfs(int x)

    for (int i = 0;i < G[x].size();i++)
    
        int node = G[x][i];
        if (Vis[node] || Dis_y[node] != Dis_x[x]+1)
            continue;
        Vis[node] = 1;
        if (Link_l[node] != -1 && Dis_y[node] == dis)
            continue;
        if (Link_l[node] == -1 || Dfs(Link_l[node]))
        
            Link_l[node] = x;
            Link_r[x] = node;
            return true;
        
    
    return false;


int Solve()

    memset(Link_l, -1, sizeof(Link_l));
    memset(Link_r, -1, sizeof(Link_r));
    int cnt = 0;
    while (Search())
    
        memset(Vis, 0, sizeof(Vis));
        for (int i = 1;i <= m;i++)
        
            if (Link_r[i] == -1 && Dfs(i))
                cnt++;
        
    
    return cnt;


int main()

    int t, cnt = 0;
    scanf("%d", &t);
    while (t--)
    
        int time;
        scanf("%d", &time);
        scanf("%d", &m);
        for (int i = 1;i <= m;i++)
            G[i].clear();
        for (int i = 1;i <= m;i++)
            scanf("%lf%lf%lf", &P[i].x, &P[i].y, &Speed[i]);
        scanf("%d", &n);
        for (int i = 1;i <= n;i++)
            scanf("%lf%lf", &U[i].x, &U[i].y);
        for (int i = 1;i <= m;i++)
        
            for (int j = 1;j <= n;j++)
            
                double len = GetLen(P[i], U[j]);
                if (len/Speed[i] <= time)
                    G[i].push_back(j);
            
        
        int sum = Solve();
        printf("Scenario #%d:\n%d\n\n", ++cnt, sum);
    

    return 0;