HDU 3656 DLX重复覆盖

/*********************************************************************************
    纠结了良久，这个题是DLX的重复覆盖问题，以前还没见过，最后套了晓天大牛的模板，水过了。
还是模板题。。。因为最后的答案必然是某两点的距离，所以离散化一下所有距离后二分再套用DLX
重复覆盖模板就能AC了～赞一下神函数unique_copy，这个模板的细节还是要很小心才行，
计数都要从1开始～
*********************************************************************************/
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <cstdio>
#include <vector>
#include <cmath>
#include <ctime>
#include <map>
#include <set>
using namespace std;

typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;

const int INF_INT = 0x3f3f3f3f;
const double oo = 10e9;
const double eps = 10e-7;

const int MAXN = 104;
const int MAXM = MAXN * MAXN;

PII house[MAXN];
int test, n, m;
int dtop, dis[MAXM], laby[MAXN][MAXN];
int nodecnt;
int U[MAXM], L[MAXM], D[MAXM], R[MAXM], row[MAXM], col[MAXM];
int sz[MAXN];
bool vis[MAXN], maze[MAXN][MAXN];

int sqa_dist(const PII &pa, const PII &pb)
{
    return (pa.first - pb.first) * (pa.first - pb.first) + 
            (pa.second - pb.second) * (pa.second - pb.second);
}
void initDLX(int mm)
{
    memset(sz, 0, sizeof(sz));
    memset(col, -1, sizeof(col));
    nodecnt = mm + 1;
    for (int i = 0; i <= mm; ++i)
    {
        L[i] = i - 1;
        R[i] = i + 1;
        U[i] = D[i] = i;
        col[i] = i;
    }
    L[0] = mm;
    R[mm] = 0;
    sz[0] = INF_INT;
    return ;
}
void insert(int id, int *tt, int c)
{
    for (int i = 0; i < c; ++i, ++nodecnt)
    {
        int x = tt[i];
        row[nodecnt] = id;
        col[nodecnt] = x;
        ++sz[x];
        U[nodecnt] = x;
        D[nodecnt] = D[x];
        U[ D[x] ] = nodecnt;
        D[x] = nodecnt;
        if (0 == i)
        {
            L[nodecnt] = R[nodecnt] = nodecnt;
        }
        else
        {
            L[nodecnt] = nodecnt - 1;
            R[nodecnt] = nodecnt - i;
            R[nodecnt - 1] = nodecnt;
            L[nodecnt - i] = nodecnt;
        }
    }
    return ;
}
void buildDLX(int key)
{
    int tt[MAXN], c;
    memset(maze, false, sizeof(maze));
    for (int i = 1; i <= n; ++i)
    {
        for (int j = 1; j <= n; ++j)
        {
            maze[i][j] = (laby[i][j] <= key);
        }
    }
    for (int i = 1; i <= n; ++i)
    {
        c = 0;
        for (int j = 1; j <= n; ++j)
        {
            if (maze[i][j])
            {
                tt[c++] = j;
            }
        }
        insert(i, tt, c);
    }
    return ;
}
void remove(int x)
{
    for (int i = D[x]; i != x; i = D[i])
    {
        L[ R[i] ] = L[i];
        R[ L[i] ] = R[i];
        --sz[ col[i] ];
    }
    return ;
}
void resume(int x)
{
    for (int i = U[x]; i != x; i = U[i])
    {
        L[ R[i] ] = i;
        R[ L[i] ] = i;
        ++sz[ col[i] ];
    }
    return ;
}
int h()
{
    memset(vis, false, sizeof(vis));
    int res = 0;
    for (int i = R[0]; i != 0; i = R[i])
    {
        if (vis[ col[i] ])
        {
            continue ;
        }
        vis[ col[i] ] = true;
        ++res;
        for (int j = D[i]; j != i; j = D[j])
        {
            if (col[j] != 0)
            {
                for (int k = R[j]; k != j; k = R[k])
                {
                    vis[ col[k] ] = true;
                }
            }
        }
    }
    return res;
}
bool dfs(int step, int key)
{
    if (h() + step > m)
    {
        return false;
    }
    if (0 == R[0])
    {
        return true;
    }
    int id = 0;
    for (int i = R[0]; i != 0; i = R[i])
    {
        if (sz[i] < sz[id])
        {
            id = i;
        }
    }
    for (int i = D[id]; i != id; i = D[i])
    {
        remove(i);
        for (int j = R[i]; j != i; j = R[j])
        {
            remove(j);
        }
        if (dfs(step + 1, key))
        {
            return true;
        }
        for (int j = L[i]; j != i; j = L[j])
        {
            resume(j);
        }
        resume(i);
    }
    return false;
}
double bisearch()
{
    int low = 0, high = dtop - 1, mid = (low + high) >> 1;
    int res = mid, key;
    while (low <= high)
    {
        mid = (low + high) >> 1;
        key = dis[mid];
        initDLX(n);
        buildDLX(key);
        if (dfs(0, key))
        {
            res = mid;
            high = mid - 1;
        }
        else
        {
            low = mid + 1;
        }
    }
    return sqrt(dis[res] + 0.0);
}
void ace()
{
    double ans;
    for (scanf("%d", &test); test--; )
    {
        scanf("%d %d", &n, &m);
        for (int i = 1; i <= n; ++i)
        {
            scanf("%d %d", &house[i].first, &house[i].second);
        }
        dtop = 0;
        for (int i = 1; i <= n; ++i)
        {
            for (int j = 1; j <= n; ++j)
            {
                laby[i][j] = dis[dtop++] = sqa_dist(house[i], house[j]);
            }
        }
        sort(dis, dis + dtop);
        dtop = unique_copy(dis, dis + dtop, dis) - dis;
        ans = bisearch();
        printf("%.6lf\n", ans);
    }
    return ;
}
int main()
{
    ace();
    return 0;
}