POJ 3241 曼哈顿最小生成树

//题意： 询问平面上的点的曼哈顿距离最小生成树第n-k小边的长度，点数为10000。
//最小生成树边权对应？？？
//1A2s险过
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<vector>
#include<algorithm>
#include<cmath>
#define inf 0x3f3f3f3f
#define maxn 10100
#define maxm 100000
using namespace std;
int n,k;
int cnt;

struct point
{
    int x,y;
}G[maxn];


int pre[maxn],rank[maxn];

struct Edge
{
    int l,r;
    int w;
};

Edge edge[maxm];

void build(int target)
{
    int dis;
    int tempx=G[target].x;
    int tempy=G[target].y;
    int indexup=0;int indexdown=0;
    int miup=inf;
    int midown=inf;
    for(int i=1;i<=n;i++)
    {
        if(i==target) continue;
        dis=abs(G[i].x-tempx)+abs(G[i].y-tempy);
        if(G[i].x>=tempx && G[i].y>tempy)
        {
            if(dis<miup  )
                indexup=i,miup=dis;
        }
        if(G[i].x>tempx && G[i].y<=tempy )
        {
            if(dis<midown)
            {
                indexdown=i,midown=dis;
            }
        }
    }
    if(indexup!=0)
    {
    edge[cnt].l=indexup;///加边求最小生成树
    edge[cnt].r=target;
    dis=abs(G[indexup].x-tempx)+abs(G[indexup].y-tempy);
    edge[cnt++].w=dis;
    }
    if(indexdown!=0)
    {
    dis=abs(G[indexdown].x-tempx)+abs(G[indexdown].y-tempy);
    edge[cnt].l=indexdown;
    edge[cnt].r=target;
    edge[cnt++].w=dis;
    }
}

void Init()
{
    for(int i=0;i<=cnt+10;i++)
    {
            pre[i] = i;
            rank[i] = 1;
    }
}

int Find(int x)
{
    if(pre[x] != x)
    pre[x] = Find(pre[x]);
    return pre[x];
}

void Union(int x,int y)//这是传说中按秩序并查么
{
    x = Find(x);
    y = Find(y);
    if(x == y) return;
    if(rank[x] >= rank[y])
    {
        pre[y] =x;
        rank[x] += rank[y];
    }
    else
    {
        pre[x] = y;
        rank[y] += rank[x];
    }
}

bool cmp(Edge a,Edge b)
{
    return a.w < b.w;
}

void Kruskal()
{
    Init();
    int ans = 0;
    sort(edge,edge+cnt,cmp);
    int edgenum=0;
    for(int i=0;i<cnt;i++)
    {
        if(edgenum==n-1)
            break;
        int x = Find(edge[i].l);
        int y = Find(edge[i].r);
        if(x != y)
        {
            Union(x,y);
            ans += edge[i].w;
            edgenum++;
            if(edgenum==n-k)
              {
                cout<<edge[i].w<<endl;return;
              }

        }
    }

}


int main()
{
    while(scanf("%d%d",&n,&k)!=EOF)
    {
    cnt=0;
    for(int i=1;i<=n;i++)
        scanf("%d%d",&G[i].x,&G[i].y);
    for(int i=1;i<=n;i++)
    build(i);
    Kruskal();
    }
}