POJ2349（最小生成树）

题目大意：给定n个点，其中任意点都可以用无线电链接，但是无线电的连接范围不能超过D，D越大费用越高，现在可以给其中的S个点接上卫星，卫星范围无限，现在要求所有点都直接或间接的连接，求最小的D

思路：

• 把所有点都连接上后，需要把他们分成s个联通块，每个连通块里放一个卫星（不管是那个点），这样，两个连通块里的所有点都可以通过卫星连接，分成s个连通块需要删掉s-1条路
• 既然要求D最小，那么就一定要删最大的s-1条边
• 那么我就需要形成生成树的所有的边都尽量小
• 因为最小生成树是按照边权从小到大排列的，满足条件
• 所以求解的步骤就是先用Kruskal求出最小生成树，求的过程中把要形成生成树的边存起来，最后删除最大的s-1条边，然后输出最大边即可

//poj2349
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<queue>
using namespace std;
const int MAXN = 500 * 500 + 10;
int x[MAXN], y[MAXN];
int fa[MAXN];
int s, n;
int ans;

struct edge
{
    int u, v;
    double w;
} e[MAXN];

double dist(int u, int v)
{
    return sqrt((double)(x[u]-x[v])*(x[u]-x[v])+(y[u]-y[v])*(y[u]-y[v]));
}

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

int find(int x)
{
//  if(fa[x] != x) return fa[x] = find(fa[x]);
//  else return x ;
    if(fa[x] == x) return x;
    else return fa[x] = find(fa[x]);
}

double q[MAXN];
void kruskal(int cnt)
{
    memset(q, 0, sizeof(q));
    for(int i = 1; i <= n; i++)
        fa[i] = i;

    for(int i = 1; i <= cnt; i++)
    {
        int a = e[i].u, b = e[i].v;
        int fx = find(a), fy = find(b);
        if(fx != fy) {fa[fy] = fx; q[++ans] = e[i].w;}
    }
}

int main()
{
    int t;
    cin >> t;
    while(t--)
    {
        cin >> s >> n;
        for(int i = 1; i <= n; i++)
            cin >> x[i] >> y[i];

        int cnt = 0;    
        for(int i = 1; i <= n; i++)
            for(int j = i+1; j <= n; j++)
            {
                e[++cnt].w = dist(i, j);
                e[cnt].u = i, e[cnt].v = j;
            }

        sort(e+1, e+1+cnt, cmp);

        ans = 0;
        kruskal(cnt);

        int to = ans - s + 1;
        while(ans != to)
            ans--;
        printf("%.2f\n", q[ans]);
//      cout << q[ans] << endl;

    }
    return 0;
}