hdu 5046 Airport

        题意：n个城市，建k个飞机场。你需要使离飞机场最远的城市距离飞机场最近。距离的定义是横坐标的差+纵坐标的差。

        思路：二分距离，DLX判断能否满足要求（城市i到城市j距离如果小于等于当前距离，矩阵对应位置置1，否则置0）。直接上的模板。。貌似c++的abs()函数返回类型是int，坑了我好多发。。

#include<iostream>
#include<queue>
#include<map>
#include<set>
#include<vector>
#include<algorithm>
#include<string.h>
#include<cstdio>

using namespace std;

#define ll long long
#define INF 1000000000

int n,k;

struct DLX{  
    const static int maxn=4000;  
    #define FF(i,A,s) for(int i = A[s];i != s;i = A[i])  
    int L[maxn],R[maxn],U[maxn],D[maxn];  
    int size,col[maxn],row[maxn],s[maxn],H[maxn];  
    bool vis[70];  
    int ans[maxn],cnt;  
    void init(int m){  
        for(int i=0;i<=m;i++){  
            L[i]=i-1;R[i]=i+1;U[i]=D[i]=i;s[i]=0;  
        }  
        memset(H,-1,sizeof(H));  
        L[0]=m;R[m]=0;size=m+1;  
    }  
    void link(int r,int c){  
         U[size]=c;D[size]=D[c];U[D[c]]=size;D[c]=size;  
         if(H[r]<0)H[r]=L[size]=R[size]=size;  
         else {  
             L[size]=H[r];R[size]=R[H[r]];  
             L[R[H[r]]]=size;R[H[r]]=size;  
         }  
         s[c]++;col[size]=c;row[size]=r;size++;  
     }  
    void del(int c){//精确覆盖  
        L[R[c]]=L[c];R[L[c]]=R[c];    
        FF(i,D,c)FF(j,R,i)U[D[j]]=U[j],D[U[j]]=D[j],--s[col[j]];    
    }    
    void add(int c){  //精确覆盖  
        R[L[c]]=L[R[c]]=c;    
        FF(i,U,c)FF(j,L,i)++s[col[U[D[j]]=D[U[j]]=j]];    
    }    
    bool dfs(int k){//精确覆盖  
        if(!R[0]){    
            cnt=k;return 1;    
        }    
        int c=R[0];FF(i,R,0)if(s[c]>s[i])c=i;    
        del(c);    
        FF(i,D,c){    
            FF(j,R,i)del(col[j]);    
            ans[k]=row[i];if(dfs(k+1))return true;    
            FF(j,L,i)add(col[j]);    
        }    
        add(c);    
        return 0;  
    }    
    void remove(int c){//重复覆盖  
        FF(i,D,c)L[R[i]]=L[i],R[L[i]]=R[i];  
    }  
     void resume(int c){//重复覆盖  
         FF(i,U,c)L[R[i]]=R[L[i]]=i;  
     }  
    int A(){//估价函数  
        int res=0;  
        memset(vis,0,sizeof(vis));  
        FF(i,R,0)if(!vis[i]){  
                res++;vis[i]=1;  
                FF(j,D,i)FF(k,R,j)vis[col[k]]=1;  
            }  
        return res;
    }  
    bool dfs(int now,int ans){//重复覆盖  
        if(R[0]==0)return 1;  
        else if(now+A()<=ans){  
            int temp=INF,c;  
            FF(i,R,0)if(temp>s[i])temp=s[i],c=i;  
            FF(i,D,c){  
                remove(i);FF(j,R,i)remove(j);  
                if(dfs(now+1,ans))return 1;  
                FF(j,L,i)resume(j);resume(i);  
            }  
        }
        return 0; 
    }
};  

DLX dlx;
ll x[64];
ll y[64];

ll dis(int a,int b){
	return (ll)abs(x[a]-x[b])+(ll)abs(y[a]-y[b]);//如果不加(ll)，c++交就过不了，神坑。。。 
}

int main(){
    int t;
    cin>>t;
    int cas=0;
    while(t--){
        cas++;
        cin>>n>>k;
        for(int i=0;i<n;i++){
            cin>>x[i]>>y[i];
        }
        
        ll MIN=0;
        ll MAX=4000000000LL;
        ll ans=0;
        
        while(MIN<=MAX){
            ll mid=(MIN+MAX)>>1;
            dlx.init(n);
            
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    if(dis(i,j)<=mid){
                        dlx.link(i+1,j+1);
                    }
                }
            }
            if(dlx.dfs(0,k)){
                ans=mid;
                MAX=mid-1;
            }else{
                MIN=mid+1;
            }
        }
        cout<<"Case #"<<cas<<": "<<ans<<endl;
    }
    return 0;
}