HDU 2295 Radar （二分 + Dancing Links 重复覆盖模型 ）

以下转自 这里 ：

最小支配集问题：二分枚举最小距离，判断可行性。可行性即重复覆盖模型，DLX解之。

A*的启发函数：

对当前矩阵来说，选择一个未被控制的列，很明显该列最少需要1个行来控制，所以ans++。

该列被控制后，把它所对应的行，全部设为已经选择，并把这些行对应的列也设为被控制。继续选择未被控制的列，直到没有这样的列。

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>

using namespace std;

const double eps = 1e-;
const int INF =  << ;
const int MAXN = ;

struct Point
{
    double x, y;
    Point( double x = , double y =  ):x(x), y(y) { }
    void readPoint()
    {
        scanf( "%lf%lf", &x, &y );
        return;
    }
};

Point city[MAXN];
Point radar[MAXN];

int N, M, K;
int L[MAXN*MAXN], R[MAXN*MAXN];
int U[MAXN*MAXN], D[MAXN*MAXN];
int C[MAXN*MAXN], cnt[MAXN];
bool mx[MAXN][MAXN];
bool vis[MAXN];
int head;

void Remove( int c )
{
    for ( int i = D[c]; i != c; i = D[i] )
    {
        R[ L[i] ] = R[i];
        L[ R[i] ] = L[i];
    }
    return;
}

void Resume( int c )
{
    for ( int i = D[c]; i != c; i = D[i] )
    {
        R[ L[i] ] = i;
        L[ R[i] ] = i;
    }
    return;
}

//估价函数：至少还需要选择几个雷达
int h()
{
    memset( vis, false, sizeof(vis) );
    int res = ;
    for ( int c = R[head]; c != head; c = R[c] )
    {
        if ( !vis[c] )
        {
            ++res;
            for ( int i = D[c]; i != c; i = D[i] )
                for ( int j = R[i]; j != i; j = R[j] )
                    vis[ C[j] ] = true;
        }
    }
    return res;
}

bool DFS( int dep )
{
    if ( R[head] == head ) return true;
    if ( dep + h() > K ) return false;
    int minv = INF, c;

    for ( int i = R[head]; i != head; i = R[i] )
    {
        if ( cnt[i] < minv )
        {
            minv = cnt[i];
            c = i;
        }
    }

    for ( int i = D[c]; i != c; i = D[i] )
    {
        Remove(i);
        for ( int j = R[i]; j != i; j = R[j] )
        {
            Remove(j);
            --cnt[ C[j] ];
        }
        if ( DFS( dep +  ) ) return true;
        for ( int j = R[i]; j != i; j = R[j] )
        {
            Resume(j);
            ++cnt[ C[j] ];
        }
        Resume(i);
    }

    return false;
}

bool build()
{
    head = ;
    for ( int i = ; i < N; ++i )
    {
        R[i] = i + ;
        L[i + ] = i;
    }
    R[N] = ;
    L[] = N;

    //列链表
    for ( int j = ; j <= N; ++j )
    {
        int pre = j;
        cnt[j] = ;
        for ( int i = ; i <= M; ++i )
        {
            if ( mx[i][j] )
            {
                ++cnt[j];
                int cur = i * N + j;
                D[pre] = cur;
                U[cur] = pre;
                C[cur] = j;
                pre = cur;
            }
        }
        U[j] = pre;
        D[pre] = j;
        if ( !cnt[j] ) return false;
    }

    for ( int i = ; i <= M; ++i )
    {
        int pre = -;
        int first = -;
        for ( int j = ; j <= N; ++j )
        {
            if ( mx[i][j] )
            {
                int cur = i * N + j;
                if ( pre == - ) first = cur;
                else
                {
                    R[pre] = cur;
                    L[cur] = pre;
                }
                pre = cur;
            }
        }
        if ( first != - )
        {
            L[first] = pre;
            R[pre] = first;
        }
    }
    return true;
}

/*************以上DLX模板***************/

double PointDis( Point a, Point b )
{
    return sqrt( (a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y) );
}

int dcmp( double x )    //控制精度
{
    if ( fabs(x) < eps ) return ;
    else return x <  ? - : ;
}

bool check( double mid )
{
    memset( mx, false, sizeof(mx) );

    for ( int i = ; i <= M; ++i )
        for ( int j = ; j <= N; ++j )
        {
            if ( dcmp( PointDis( radar[i], city[j] ) - mid ) <  )
                mx[i][j] = true;
        }

    if ( build() ) return DFS();
    return false;
}

double solved()
{
    double l = 0.0;
    double r = 1500.0;
    double ans;
    while ( dcmp( r - l ) >  )
    {
        double mid = (l + r) / 2.0;
        if ( check( mid ) )
        {
            r = mid;
            ans = mid;
        }
        else l = mid;
    }
    return ans;
}

int main()
{
    int T;
    scanf( "%d", &T );
    while ( T-- )
    {
        scanf( "%d%d%d", &N, &M, &K );
        for( int i = ; i <= N; ++i )
            city[i].readPoint();
        for ( int i = ; i <= M; ++i )
            radar[i].readPoint();

        printf( "%.6f\n", solved() );
    }
    return ;
}