Arctic Network POJ

The Department of National Defence (DND) wishes to connect several northern outposts by a wireless network. Two different communication technologies are to be used in establishing the network: every outpost will have a radio transceiver and some outposts will in addition have a satellite channel. 
Any two outposts with a satellite channel can communicate via the satellite, regardless of their location. Otherwise, two outposts can communicate by radio only if the distance between them does not exceed D, which depends of the power of the transceivers. Higher power yields higher D but costs more. Due to purchasing and maintenance considerations, the transceivers at the outposts must be identical; that is, the value of D is the same for every pair of outposts. 

Your job is to determine the minimum D required for the transceivers. There must be at least one communication path (direct or indirect) between every pair of outposts.

Input

The first line of input contains N, the number of test cases. The first line of each test case contains 1 <= S <= 100, the number of satellite channels, and S < P <= 500, the number of outposts. P lines follow, giving the (x,y) coordinates of each outpost in km (coordinates are integers between 0 and 10,000).

Output

For each case, output should consist of a single line giving the minimum D required to connect the network. Output should be specified to 2 decimal points.

Sample Input

1
2 4
0 100
0 300
0 600
150 750

Sample Output

212.13

题意：有大概500个站点，站点直接可以以用信号接收器连接，也可以用卫星连接，卫星连接不需要成本但只有但两个站点都有卫星的频道时才能连接，信号接收器需要花费金钱买，而且信号接收器的信号半径有不同信号的，
输入第一行为测试样例数，每个测试样例第一行为已有卫星频道数s,站点数p,往下有p行，每行都表示一个站点的坐标(x,y),0<=x,y<=10000;
输出：问在保证所有站点都能连接的情况下，需要购买的信号接收器的最大半径时多少。

思路：首先可以看出这个题相当于在求最小生成树后问点与点之间的最大距离，但由于有卫星的存在因此这个距离不一定时树的最大距离，
首先我们要将站点之间的距离求出并放入一个容器中，然后按照Kruskal算法求出最小生成树，然后对树的每一个枝条也就是树中的边进行遍历，由于卫星的存在因此可以删掉s-1个枝条，则剩下的枝条的最大距离即是答案
要注意在每个测试过后都需要把容器清零；

代码：

#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#include <sstream>
#include <iostream>
#define mod 998244353
#define eps 1e-6
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;

//u表示起点，v表示终点，cost表示花费
struct node
{
    int u,v;
    double cost;
};
//排序，从小到大
bool cmp(node a,node b)
{
    return a.cost<b.cost;
}
//存放边的信息
vector<node> ve;

//fa表示当前i的最远祖先
int fa[505];
//初始化fa，开始时自己是自己的祖先
void init(int qwq)
{
    for(int i=0;i<=qwq;i++)
    {
        fa[i]=i;
    }
}
//查找最远祖先，同时进行路径压缩
int find(int x)
{
    if(fa[x]==x)
    {
        return x;
    }
    return fa[x]=find(fa[x]);
}
//判断最远祖先是否相同
bool che(int x,int y)
{
    return find(x)==find(y);
}
//合并x,y，把他们放到同一个家族中
void mer(int x,int y)
{
    if(!che(x,y)) 
    {
        fa[fa[x]]=fa[y];
    }
    return ;
}
int n,m;
struct dian
{
    double x,y;
};
dian di[505];
vector<node> aggre;
double dist(dian a,dian b)
{
    return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
}
int main()
{
    scanf("%d",&n);
    while(n--)
    {
        int s,p;
        scanf("%d %d",&s,&p);
        //初始化
        init(p);
        for(int i=0;i<p;i++)
        {
            scanf("%lf %lf",&di[i].x,&di[i].y);
        }
        node no;
        //将站点的位置信息转换成点与点之间的距离并放入到容器中
        for(int i=0;i<p-1;i++)
        {
            for(int j=i+1;j<p;j++)
            {
                no.u=i;
                no.v=j;
                no.cost=dist(di[i],di[j]);
                ve.push_back(no);
            }
        }
        //排序
        sort(ve.begin(),ve.end(),cmp);
        //算法求出树的枝条并放入另一个容器中
        for(int i=0;i<ve.size();i++)
        {
            if(!che(ve[i].u,ve[i].v))
            {
                mer(ve[i].u,ve[i].v);
                no = ve[i];
                aggre.push_back(no);
            }
        }
        //排序
        sort(aggre.begin(),aggre.end(),cmp);
        int ans=aggre.size()-1;
        //从小到大，再减去卫星连接的枝条，
        if(s-1>0)
        {
            ans-=(s-1);
        }
        printf("%.2lf
",aggre[ans].cost);
        //清除容器的内容
        ve.clear();
        aggre.clear();
    }
}