来更新一篇blog吧

最近做了一下hackerrank的20/20的比赛。平时都只能过2题，这周顺利地通过了四道题目竟然。当妄图冲击衬衫的时候，发现剩下三个题一点招数都没有，之后就跑去看了一下node.js了。。。

这次比赛的第四个题目是用cpp敲的，之前都是偷懒用python。

题目链接

Bike Racers

【题意描述】

在城市里有n个骑车的人，有m辆自行车，人可以同时沿着任意方向行走，每单位时间移动单位距离。要求出前k个到达自行车的人所花费的最小时间。人和自行车都用整数坐标表示。

1 <= N <= 250
1 <= M <= 250
1 <= K <= min(N,M)
0 <= x_i,y_i <= 10⁷

【思路】

这一个题目，拿到之后没什么想法。然后感觉应该像是二分图的匹配问题。然后就去恶补了二分图，刷了三四道题目。第二天晚上回来，发现确实是二分图……那么大意就是求出这个图的一个子图，这个子图的二分图匹配数为k并且匹配的边中最大值最小。

那么这道题可以用类似克鲁斯卡尔最小生成树的问题来解决。将边从小到大进行排序，依次添加到图中。每次添加检测匹配数，当匹配数为k的时候，最后添加的那条边就是所求解。匹配当然是采用匈牙利算法进行。

算法确定，之后就是数据结构的问题：

如何保存图是本题的关键。

假设边以经按照权值排序完成。加边只修要O（1）的时间。

题目的总体复杂度为V*匈牙利算法的复杂度（V为边数）

匈牙利算法的复杂度为DFS的复杂度V*E（边数*点数）

通常的题目中，使用邻接矩阵来保存图，匈牙利算法就退化成为了E*E*E（V=E*E），于是总体复杂度就变成了E^5。必须会TLE。

世界就是如此美好，这个时候如果用边表来保存整个图，那么每次匈牙利算法的复杂度仍旧是V*E,总体复杂度就变为了（E*1+E*2+……+E*E*E）=1/2*(E^3)*(E+1)大约为E^4。看上去好很多了。

排序的优化：

为了让算法看上去更快一点，我又对排序这个地方产生了想法，如果排序的话，排序的复杂度为:

V*logV = E*E*log(E*E) = 2E*ElogE。在最坏的情况下，加入了最后一条边才能出结果，这个时候复杂度是不会有改善的。这里考虑平均情况，也就是说不需要每次都用到所有的边，这个时候使用小顶堆可以胜任！

以下是拙劣的代码。窃喜一下，还是觉得有长进的…

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

struct Point {
    long long x,y;
    Point( long long _x, long long _y ) {
        x = _x;
        y = _y;
    }
    Point() {}
    long long dis( Point p ) {
        long long lx = x - p.x;
        long long ly = y - p.y;
        lx *= lx;
        ly *= ly;
        return lx+ly;
    }
};

struct Edge {
    int y,next;
    long long l;
    Edge ( int _y, long long  _l, int _next ) {
        y = _y;
        next = _next;
        l = _l;
    }
    Edge () {}
};

struct E{
    int x,y;
    long long l;
    E( int _x, int _y, long long _l ) {
        x = _x;
        y = _y;
        l = _l;
    }
    E(){}
    bool operator<( const E &e ) const {
        return l > e.l;
    }
};

const int MAXSIZE = 255;
const int NC = MAXSIZE*2;

priority_queue<E> Q;

int head[NC];
Edge e[MAXSIZE*MAXSIZE];
Point p[MAXSIZE];
int visited[NC];
int mark[NC];


int e_len;
int n,m,k;
long long last;

void add( E ex ) {
    e[e_len] = Edge(ex.y,ex.l,head[ex.x]);
    head[ex.x] = e_len++;
}

void input() {
    while ( !Q.empty() ) {
        Q.pop();
    }
    memset(e,-1,sizeof(e));
    memset(head,-1,sizeof(head));
    memset(p,0,sizeof(p));
    e_len = 0;
    cin>>n>>m>>k;
    for ( int i = 0; i < n; i++ ) {
        long long x,y;
        cin>>x>>y;
        p[i] = Point(x,y);
    }
    for ( int i = 0; i < m; i++ ) {
        long long x,y;
        cin>>x>>y;
        Point t(x,y);
        for ( int j = 0; j < n; j++ ) {
            Q.push(E(j,MAXSIZE+i,t.dis(p[j])));
        }
    }
}

int DFS( int x ) {
    for ( int i = head[x]; i != -1; i = e[i].next ) {
        int y = e[i].y;
        if ( !visited[y] ) {
            visited[y] = 1;
            if ( ( -1 == mark[y] ) || ( DFS(mark[y]) ) ) {
                mark[y] = x;
                return 1;
            }
        }
    }
   return 0;
}

bool test() {
    memset(mark,-1,sizeof(mark));
    int result = 0;
    for ( int i = 0; i < n; i++ ) {
        memset(visited,0,sizeof(visited));
        result += DFS(i);
    }
    if ( result == k ) {
        return true;
    } else {
        return false;
    }
}

void solve () {
    for ( int i = 0; i < k; i++ ) {
        E ex = Q.top();
        Q.pop();
        add(ex);
        last = ex.l;
    }
    while ( !test() ) {
        E ex = Q.top();
        Q.pop();
        add(ex);
        last = ex.l;
    }
    cout<<last<<endl;
}

int main() {
    input();
    solve();
}