Arctic Network POJ

题目链接：https://vjudge.net/problem/POJ-2349

思路：

题目说，有很多个网络点，每个网络点需要雷达相连，题目还会给指定数量的超级雷达，

每两个超级雷达直接可以直接连接，且没有距离限制，问能使得所有网络点相连，

雷达信号最小半径需要多大。我们可以直接跑一次最小生成树，然后把每个点的权值从大到小排序，

因为有超级雷达的存在，那么我们可以让最大权值的地方用超级雷达让这个权值变为0。

include <stdio.h>
#include <iostream>
#include <queue>
#include <math.h>
#include <algorithm>
using namespace std;

const int N = (int)1e3 + 10;
const int inf = (int)1e9;
double px[N];
double py[N];
double g[N][N];
double dis[N];
bool vis[N];
int s,p;

struct node{
    int loc;
    double w;
    bool friend operator<(const node & a,const node& b){
        return a.w > b.w;
    }
};
priority_queue<node > que;

bool cmp(double x,double y){
    return x > y;
}

inline double dist(int a,int b){
    return sqrt((px[a]-px[b])*(px[a]-px[b])+(py[a]-py[b])*(py[a]-py[b]));
}

void build_map(){

    for(int i = 1; i <= p; i++)
        for(int j = 1; j <= p; j++)
            g[i][j] = g[j][i] = dist(i,j);

}

double prime(){

    for(int i = 1; i <= p; i++){
        vis[i] = 0;
        dis[i] = inf;
    }

    while(!que.empty()) que.pop();

    que.push(node{1,0});
    dis[1] = 0;

    while(!que.empty()){
        int u = que.top().loc;
        que.pop();
        vis[u] = true;

        for(int v = 1; v <= p ;v++){
            if(!vis[v] && dis[v] > g[u][v]){
                dis[v] = g[u][v];
                que.push(node{v,dis[v]});
            }
        }
    }
    sort(dis+1,dis+1+p,cmp);
    /*
    for(int i = 1; i <= p; i++)
        printf("%lf
",dis[i]);
    */


    return dis[s];
}

int main(){

    int T;
    scanf("%d",&T);

    while(T--){
        scanf("%d%d",&s,&p);

        for(int i = 1; i <= p; i++)
            scanf("%lf%lf",&px[i],&py[i]);

        build_map();

        printf("%.2f
",prime());
    }

    return 0;
}