poj3241 曼哈顿最小距离生成树第k大的边

思路：

已知：

要生成曼哈顿距离最小生成树，一个点最多和四周8个点连线，那8个点分别是将那个点四周360度平分成8个区间，每个区间里面和那个点曼哈顿距离最小的点，所以如果有n个点，那么最多有4n条边，然后就可以用kruskal算法去做。

 #include <iostream>    //poj3241 曼哈顿距离最小生成树第k大的边
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <climits>
 #define mid ((l+r)>>1)
 using namespace std;

 int ent;

 int temp1,temp2,temp3;

 int fa[];

 class Point
 {
 public:
     int x,y,id;
 } point[];

 class Tree
 {
 public:
     int index,current;
 } tree[<<];

 class Edge
 {
 public:
     int s,t,dis;
 } edge[];

 bool cmp(Point a,Point b)
 {
     if(a.x==b.x)
         return a.y<b.y;
     return a.x<b.x;
 }

 bool cmp2(Edge a,Edge b)
 {
     return a.dis<b.dis;
 }

 int get_ans(Point a)
 {
     return a.y-a.x+;
 }

 int get_dis(int a,int b)
 {
     return point[b].x+point[b].y-point[a].x-point[a].y;
 }

 void build(int l,int r,int n)
 {
     tree[n].index=INT_MAX;
     if(l==r)
     {
         tree[n].current=l;
         return;
     }
     build(l,mid,n<<);
     build(mid+,r,n<<|);
 }

 void update(int l,int r,int n,int current,int aim)
 {
     int ans=point[aim].x+point[aim].y;
     if(ans<tree[n].index)
         tree[n].index=ans;
     if(l==r)
     {
         if(ans==tree[n].index)
             tree[n].current=aim;
         return;
     }
     if(mid<current)
         update(mid+,r,n<<|,current,aim);
     else update(l,mid,n<<,current,aim);
 }

 void search(int l,int r,int n,int current,int aim)
 {
     if(l==r)
     {
         if(tree[n].index<temp1)
         {
             temp1=tree[n].index;
             temp2=tree[n].current;
         }
         return;
     }
     if(mid<current)
         search(mid+,r,n<<|,current,aim);
     else if(l>=current)
     {
         if(tree[n<<].index<tree[n<<|].index)
             search(l,mid,n<<,current,aim);
         else search(mid+,r,n<<|,current,aim);
     }
     else
     {
         if(tree[n<<].index>=tree[n<<|].index)
             search(mid+,r,n<<|,current,aim);
         else
         {
             search(l,mid,n<<,current,aim);
             search(mid+,r,n<<|,current,aim);
         }
     }
 }

 int find(int x)
 {
     int temp=x;
     while(x!=fa[x])
         x=fa[x];
     while(temp!=fa[temp])
     {
         temp=fa[temp];
         fa[temp]=x;
     }
     return x;
 }

 int pos[];
 bool sign[];
 int ans[];

 int main()
 {
     int n,k;
     while(cin>>n>>k)
     {
         int m=;
         ent=;
         memset(sign,false,sizeof(sign));
         for(int i=; i<n; i++)
         {
             scanf("%d%d",&point[i].x,&point[i].y);
             point[i].id=i;
         }
         for(int tot=; tot<; tot++)
         {
             if(tot==)
             {
                 for(int i=; i<n; i++)
                     point[i].y=-point[i].y;
             }
             if(tot==||tot==)
             {
                 for(int i=; i<n; i++)
                 {
                     point[i].x=point[i].x+point[i].y;
                     point[i].y=point[i].x-point[i].y;
                     point[i].x=point[i].x-point[i].y;
                 }
             }
             for(int i=; i<n; i++)
             {
                 int temp=get_ans(point[i]);
                 if(!sign[temp])
                 {
                     pos[m++]=temp;
                     sign[temp]=true;
                 }
             }
             sort(pos,pos+m);
             for(int i=; i<m; i++)
             {
                 ans[pos[i]]=i;
             }
             sort(point,point+n,cmp);
             build(,m-,);
             for(int i=n-; i>; i--)
             {
                 update(,m-,,ans[get_ans(point[i])],i);
                 temp1=INT_MAX;
                 search(,m-,,ans[get_ans(point[i-])],i-);
                 if(temp1!=INT_MAX)
                 {
                     edge[ent].s=point[i-].id,edge[ent].t=point[temp2].id;
                     edge[ent++].dis=get_dis(i-,temp2);
                 }
             }
         }
         sort(edge,edge+ent,cmp2);
         for(int i=; i<=n; i++)
             fa[i]=i;
         int tot=;
         for(int i=; i<ent; i++)
         {
             int x=find(edge[i].s);
             int y=find(edge[i].t);
             if(x==y)
                 continue;
             else
             {
                 fa[y]=x;
                 tot++;
             }
             if(tot==n-k)
             {
                 cout<<edge[i].dis<<endl;
                 break;
             }
         }
     }
     return ;
 }