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[11000];

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

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

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

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+1100;
}

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<<1);
    build(mid+1,r,n<<1|1);
}

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+1,r,n<<1|1,current,aim);
    else update(l,mid,n<<1,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+1,r,n<<1|1,current,aim);
    else if(l>=current)
    {
        if(tree[n<<1].index<tree[n<<1|1].index)
            search(l,mid,n<<1,current,aim);
        else search(mid+1,r,n<<1|1,current,aim);
    }
    else
    {
        if(tree[n<<1].index>=tree[n<<1|1].index)
            search(mid+1,r,n<<1|1,current,aim);
        else
        {
            search(l,mid,n<<1,current,aim);
            search(mid+1,r,n<<1|1,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[2200];
bool sign[2200];
int ans[2200];

int main()
{
    int n,k;
    while(cin>>n>>k)
    {
        int m=0;
        ent=0;
        memset(sign,false,sizeof(sign));
        for(int i=0; i<n; i++)
        {
            scanf("%d%d",&point[i].x,&point[i].y);
            point[i].id=i;
        }
        for(int tot=0; tot<4; tot++)
        {
            if(tot==2)
            {
                for(int i=0; i<n; i++)
                    point[i].y=-point[i].y;
            }
            if(tot==1||tot==3)
            {
                for(int i=0; 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=0; 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=0; i<m; i++)
            {
                ans[pos[i]]=i;
            }
            sort(point,point+n,cmp);
            build(0,m-1,1);
            for(int i=n-1; i>0; i--)
            {
                update(0,m-1,1,ans[get_ans(point[i])],i);
                temp1=INT_MAX;
                search(0,m-1,1,ans[get_ans(point[i-1])],i-1);
                if(temp1!=INT_MAX)
                {
                    edge[ent].s=point[i-1].id,edge[ent].t=point[temp2].id;
                    edge[ent++].dis=get_dis(i-1,temp2);
                }
            }
        }
        sort(edge,edge+ent,cmp2);
        for(int i=0; i<=n; i++)
            fa[i]=i;
        int tot=0;
        for(int i=0; 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 0;
}