HDU2389 Rain on your Parade（二分图匹配 ，HK算法 ）

匈牙利算法果断超时，只有用HK模板测试一下

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<string>
#include<cstring>
#include<stack>
#include<queue>
#include<vector>
#include<cstdlib>
#define lson (rt<<1),L,M
#define rson (rt<<1|1),M+1,R
#define M ((L+R)>>1)
#define cl(a,b) memset(a,b,sizeof(a));
#define LL long long
#define P pair<int,int>
#define X first
#define Y second
#define pb push_back
#define fread(zcc)  freopen(zcc,"r",stdin)
#define fwrite(zcc) freopen(zcc,"w",stdout)
using namespace std;
/*这个算法比匈牙利算法的时间复杂度要小，大数据可以采用这个算法
二分图匹配（Hopcroft-Carp的算法）。
初始化：g[][]邻接矩阵
调用：res=MaxMatch();  Nx,Ny要初始化！！！
时间复杂大为 O(V^0.5 E)
适用于数据较大的二分匹配*/
const int MAXN=3005;
const int INF=1<<28;
int g[MAXN][MAXN],Mx[MAXN],My[MAXN],Nx,Ny;
int dx[MAXN],dy[MAXN],dis;
bool vst[MAXN];
struct people{
    int x,y,t;
}p[MAXN];
struct umbrella{
    int x,y;
}um[MAXN];

int inline abs(int x){return x<0?-x:x;}
int inline distance(people a,umbrella b){
    return abs(a.x-b.x)+abs(a.y-b.y);
}
bool searchP(){
    queue<int> Q;
    dis=INF;
    memset(dx,-1,sizeof(dx));
    memset(dy,-1,sizeof(dy));
    for(int i=0;i<Nx;i++)
        if(Mx[i]==-1){
            Q.push(i);
            dx[i]=0;
        }
    while(!Q.empty()){
        int u=Q.front();
        Q.pop();
        if(dx[u]>dis)break;
        for(int v=0;v<Ny;v++)
            if(g[u][v]&&dy[v]==-1){
                dy[v]=dx[u]+1;
                if(My[v]==-1)
                    dis=dy[v];
                else{
                    dx[My[v]]=dy[v]+1;
                    Q.push(My[v]);
                }
            }
    }
    return dis!=INF;
}

bool DFS(int u){
    for(int v=0;v<Ny;v++)
       if(!vst[v]&&g[u][v]&&dy[v]==dx[u]+1){
           vst[v]=1;
           if(My[v]!=-1&&dy[v]==dis) continue;
           if(My[v]==-1||DFS(My[v])){
               My[v]=u;
               Mx[u]=v;
               return 1;
           }
       }
    return 0;
}
int MaxMatch(){
    int res=0;
    memset(Mx,-1,sizeof(Mx));
    memset(My,-1,sizeof(My));
    while(searchP()){
        memset(vst,0,sizeof(vst));
        for(int i=0;i<Nx;i++)
            if(Mx[i]==-1&&DFS(i)) res++;
    }
    return res;
}
int main(){
    int T;
    scanf("%d",&T);
    int cas=1;
    while(T--){
        int t,n,m;
        scanf("%d%d",&t,&n);
        for(int i=0;i<n;i++){
            scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].t);
        }
        scanf("%d",&m);
        for(int i=0;i<m;i++){
            scanf("%d%d",&um[i].x,&um[i].y);
        }
        cl(g,0);
        Nx=n;Ny=m;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++)if(distance(p[i],um[j])/p[i].t<=t){
                g[i][j]=1;
            }
        }
        printf("Scenario #%d:\n%d\n\n",cas++,MaxMatch());

    }
    return 0;
}

上面是之前直接把模板拿过来交的，今天，整理了下HK算法，他的优化在于每次通过BFS找到一个可以增广的路径集合，而不是匈牙利算法每次只能找到一个。下面是邻接表的HK算法

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#include<string>
#include<cstring>
#include<stack>
#include<queue>
#include<vector>
#include<cstdlib>
#define lson (rt<<1),L,M
#define rson (rt<<1|1),M+1,R
#define M ((L+R)>>1)
#define cl(a,b) memset(a,b,sizeof(a));
#define LL long long
#define P pair<int,int>
#define X first
#define Y second
#define pb push_back
#define fread(zcc)  freopen(zcc,"r",stdin)
#define fwrite(zcc) freopen(zcc,"w",stdout)
using namespace std;
const int maxn=3005;
const int inf=999999;

vector<int> G[maxn];//图
int mx[maxn],my[maxn],dx[maxn],dy[maxn];//mx[i]表示X集合i节点匹配右集合的节点号，my[]类似。dx[i]表示到左集合节点i的距离。dy类似
bool vis[maxn];//dfs的标记
int Nx,Ny,dis;
bool bfs(){
    queue<int> q;
    cl(dx,-1);
    cl(dy,-1);
    dis=inf;
    for(int i=0;i<Nx;i++){
        if(mx[i]==-1){
            q.push(i);
            dx[i]=0;
        }
    }
    while(!q.empty()){
        int u=q.front();q.pop();
        if(dx[u]>dis)break;
        for(int i=0;i<G[u].size();i++){
            int v=G[u][i];
            if(dy[v]==-1){
                dy[v]=dx[u]+1;
                if(my[v]==-1)dis=dy[v];//表示找到一条增广路了，更新最小距离
                else {
                    dx[my[v]]=dy[v]+1;
                    q.push(my[v]);
                }
            }
        }
    }
    return dis!=inf;
}
bool dfs(int u){
    int N=G[u].size();
    for(int i=0;i<N;i++){
        int v=G[u][i];
        if(!vis[v]&&dy[v]==dx[u]+1){
            vis[v]=true;
            if(my[v]!=-1&&dy[v]==dis)continue;
            if(my[v]==-1||dfs(my[v])){
                my[v]=u;
                mx[u]=v;
                return true;
            }
        }
    }
    return false;
}

int Maxmatch(){
    int ans=0;
    cl(mx,-1);
    cl(my,-1);
    while(bfs()){
        cl(vis,false);
        for(int i=0;i<Nx;i++){
            if(mx[i]==-1&&dfs(i))ans++;
        }
    }
    return ans;
}

struct people{
    int x,y,t;
}p[maxn];
struct umbrella{
    int x,y;
}um[maxn];

int inline abs(int x){return x<0?-x:x;}
int inline distance(people a,umbrella b){
    return abs(a.x-b.x)+abs(a.y-b.y);
}
int main(){
    int T;
    scanf("%d",&T);
    int cas=1;
    while(T--){
        int t,n,m;
        scanf("%d%d",&t,&n);
        for(int i=0;i<n;i++){
            scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].t);
        }
        scanf("%d",&m);
        for(int i=0;i<m;i++){
            scanf("%d%d",&um[i].x,&um[i].y);
        }
        for(int i=0;i<=n;i++)G[i].clear();
        Nx=n;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++)if(distance(p[i],um[j])/p[i].t<=t){
                G[i].pb(j);
            }
        }
        printf("Scenario #%d:\n%d\n\n",cas++,Maxmatch());
    }
    return 0;
}