HDU 5046 Airport ( Dancing Links 反复覆盖 )

今年上海网络赛的一道题目 ， 跟 HDU 2295 如出一辙 。 就是距离的计算一个是欧几里得距离 ， 一个是曼哈顿距离

学完DLX感觉这题好水 ，就是一个裸的反复覆盖

注意下别溢出即可了

#include <stdio.h>    
#include <string.h>    
#include <algorithm>    
#include <vector>    
#include <math.h>  
#include <stdlib.h>
using namespace std;    

const int maxn = 60 + 10 ;    
const int maxr = 60 + 10 ;    
const int maxnode = 60 * 60 + maxr + 10 ;    

#define FOR( i , A , s ) for( int i = A[s] ; i != s ; i = A[i] )     

struct DLX{    
	// maxn 列数 , maxnode 总节点数 , maxr 行数    
	int n , sz ;    
	int S[maxn] ;     

	int row[maxnode] , col[maxnode] ;    
	int L[maxnode] , R[maxnode] , U[maxnode] , D[maxnode] ;    
	int H[maxr] ;    

	int ansd , ans[maxr] ;    

	void init( int N ) {    
		n = N ;    
		// 第一行的虚拟结点    
		for( int i = 0 ; i <= n ; i ++ ) {    
			U[i] = D[i] = i ;    
			L[i] = i - 1 ;     
			R[i] = i + 1 ;    
		}    
		R[n] = 0 ; L[0] = n ;    
		sz = n + 1 ;    
		// 每一列的个数    
		memset( S , 0 , sizeof(S) ) ;    
		// H[i] = -1 表示这一行还没有 1     
		// 否则表示第一个 1 的 sz 是多少    
		memset( H , -1 , sizeof(H)) ;    
	}    

	// 在第r行第c列加入一个1    
	void Link( int r , int c ) {    
		row[sz] = r ;    
		col[sz] = c ;    
		S[c] ++ ;    

		D[sz] = c ; U[sz] = U[c] ;    
		D[U[c]] = sz ; U[c] = sz ;    

		if( H[r] < 0 ) { H[r] = L[sz] = R[sz] = sz ; }    
		else{    
			R[sz] = H[r] ;    
			L[sz] = L[H[r]] ;    
			R[L[sz]] = sz ;    
			L[R[sz]] = sz ;    
		}    

		sz ++ ;    

	}    

	// 删除 第 c 列    
	void remove ( int c ) {    
		FOR( i , D , c ) {  
			L[R[i]] = L[i] ;  
			R[L[i]] = R[i] ;  
		}  
	}    

	// 恢复第 c 列    
	void restore( int c ) {   
		FOR( i , D , c ) {  
			L[R[i]] = R[L[i]] = i ;  
		}  
	}    

	bool vis[maxn] ;  

	int f() {  
		int ans = 0 ;  
		FOR( i , R , 0 ) vis[i] = true ;  
		FOR( i , R , 0 ) {  
			if( vis[i] ) {  
				vis[i] = false ;  
				ans ++ ;  
				FOR( j , D , i )  
					FOR( k , R , j )  
					vis[col[k]] = false ;  
			}  
		}  
		return ans ;  
	}  

	bool dfs( int d ) {  
		// 剪枝  
		if( d + f() > best ) return false ;  
		// R[0] = 0 表示找到一个可行解  
		if( R[0] == 0 ) return d <= best ;    
		// 找到 s 最小的列 , 加快搜索的速度    
		int c = R[0] ;    
		FOR( i , R , 0 )  
			if( S[i] < S[c] ) c = i ;  
		FOR( i , D , c ) {    
			remove(i);    
			FOR( j , R , i ) remove( j );    
			if (dfs(d + 1))   
				return true ;    
			FOR( j , R , i ) restore( j ) ;    
			restore( i ) ;    
		}    
		return false ;  
	}    

	bool solve( int k ) {    
		best = k ;  
		return dfs(0) ;  
	}    
	int best ;  
} dlx ;    

int n , m , k ;  
__int64 ABS( __int64 x ) {
	return x  < 0 ? -x : x ;
}

struct Point{  
	__int64 x , y ;  
	void get(){  
		scanf( "%I64d%I64d" , &x , &y ) ;  
	}  

	friend __int64 dist ( const Point &a  , const Point & b ) {  
		return ABS( a.x - b.x ) + ABS ( a.y - b.y ) ;
	}  
};  

Point city[65] ;  

__int64 dis[60*60+10] ;

int lisanhua( int Index ) {
	int cnt = 1 ;
	for( int i = 1 ; i < Index ; i ++ ) {
		if( dis[i] != dis[i-1] ) 
			dis[cnt++] = dis[i] ;
	}
	return cnt - 1 ;
}

int main(){  
	int cas ;  
	int casn = 1 ;
	scanf( "%d" , &cas ) ;  
	while( cas -- ) {  
		scanf( "%d%d" , &n, &k ) ;  
		for( int i = 1 ; i <= n ; i ++ ) {  
			city[i].get() ;  
		} 
		int Index = 0 ;
		for( int i = 1 ; i <= n ; i ++ ) {
			for( int j = i ; j <= n ; j ++ ) {
				dis[Index++] = dist( city[i] , city[j] ) ;
			}
		}
		sort( dis , dis + Index ) ;
		Index = lisanhua( Index ) ;
		__int64 l = 0 , r = Index ;  
		__int64 mid ;  
		while( l < r ) {  
			mid = ( l + r ) / 2 ;  
			dlx.init( n ) ;  
			for( int i = 1 ; i <= n ; i ++ ) {  
				for( int j = 1 ; j <= n ; j ++ ) {  
					if( dist( city[i] , city[j] ) <= dis[mid] ) {  
						dlx.Link( i , j ) ;  
					}  
				}  
			}  
			if( dlx.solve( k ) ) {  
				r = mid ;  
			}else{  
				l = mid + 1 ;  
			}  
		}  
		printf( "Case #%d: %I64d\n" , casn ++ , dis[l] ) ;  
	}  
	return 0 ;  
}