2023/2/5总结

P2872 [USACO07DEC]Building Roads S

题目描述
Farmer John had just acquired several new farms! He wants to connect the farms with roads so that he can travel from any farm to any other farm via a sequence of roads; roads already connect some of the farms.
Each of the N (1 ≤ N ≤ 1,000) farms (conveniently numbered 1..N) is represented by a position (Xi, Yi) on the plane (0 ≤ Xi ≤ 1,000,000; 0 ≤ Yi ≤ 1,000,000). Given the preexisting M roads (1 ≤ M ≤ 1,000) as pairs of connected farms, help Farmer John determine the smallest length of additional roads he must build to connect all his farms.
给定 � n 个点的坐标，第 � i 个点的坐标为 (��,��)( xi, yi)，这 � n 个点编号为 11 到 � n。给定 � m 条边，第 � i 条边连接第 �� ui 个点和第 �� vi 个点。现在要求你添加一些边，并且能使得任意一点都可以连通其他所有点。求添加的边的总长度的最小值。
输入格式
* Line 1: Two space-separated integers: N and M
* Lines 2..N+1: Two space-separated integers: Xi and Yi
* Lines N+2..N+M+2: Two space-separated integers: i and j, indicating that there is already a road connecting the farm i and farm j.
第一行两个整数 �,� n, m 代表点数与边数。
接下来 � n 行每行两个整数 ��,�� xi, yi 代表第 � i 个点的坐标。
接下来 � m 行每行两个整数 ��,�� ui, vi 代表第 � i 条边连接第 �� ui 个点和第 �� vi 个点。
输出格式
* Line 1: Smallest length of additional roads required to connect all farms, printed without rounding to two decimal places. Be sure to calculate distances as 64-bit floating point numbers.
一行一个实数代表添加的边的最小长度，要求保留两位小数，为了避免误差， 请用 6464 位实型变量进行计算。
输入输出样例
输入 #1复制
4 1 1 1 3 1 2 3 4 3 1 4
输出 #1复制
4.00
说明/提示
数据规模与约定
对于 100%100% 的整数，1≤�,�≤10001≤ n, m≤1000，1≤��,��≤1061≤ xi, yi≤106，1≤��,��≤�1≤ ui, vi≤ n。
说明
Translated by 一只书虫仔。

1. 最小生成树问题，采用了kruscal算法。

2. 大部分都和kruscal的模板题差不多但是需要注意的是，当读入已知边的时候，我们要将这两点的距离设置为0。

3. 代码如下：

#include"stdio.h"
#include"math.h"
int n,m,f[10005];
char b[10005][10005];
struct node
{
    int x;
    int y;
}e[10005];
struct no
{
    int u;
    int v;
    double w;
}a[10005];
int find(int v)
{
    if(f[v]==v) return v;
    return f[v]=find(f[v]);
}
int hb(int v,int u)
{
    int t1,t2;
    t1=find(v);
    t2=find(u);
    if(t1!=t2)
    {
        f[t2]=t1;
        return 1;
    }
    return 0;
}
double min(double a,double b)
{
    if(a<b) return a;
    return b;
}
double jl(struct node a,struct node b)
{
    return sqrt((double)(a.x-b.x)*(a.x-b.x)+(double)(a.y-b.y)*(a.y-b.y));
}
int sort(int left,int right)
{
    if(left>=right) return 0;
    int i=left,j=right;
    struct no t,k=a[left];
    while(i<j)
    {
        while(i<j&&k.w<=a[j].w) j--;
        while(i<j&&k.w>=a[i].w) i++;
        if(i<j)
        {
            t=a[i];a[i]=a[j];a[j]=t;
        }
    }
    a[left]=a[i];
    a[i]=k;
    sort(left,i-1);
    sort(i+1,right);
}
int fun(int k)
{
    int i,j,num=1;
    double sum=0;
    for(i=0;i<k;i++)
    {
        if(hb(a[i].u,a[i].v))
        {
            sum+=a[i].w;
            num++;
            if(num>n) break;
        }
    }
    printf("%.2f",sum);
    return 0;
}
main()
{
    int i,j,u,v,k=0;
    scanf("%d %d",&n,&m);
    for(i=1;i<=n;i++)
    {
        f[i]=1;
        scanf("%d %d",&e[i].x,&e[i].y);
    }
    for(i=0;i<m;i++)
    {
        scanf("%d %d",&u,&v);
        hb(u,v);
    }
    for(i=1;i<=n;i++)
    {
        for(j=1;j<i;j++)
        {
            a[k].u=i;
            a[k].v=j;
            a[k].w=jl(e[i],e[j]);
            k++;
        }
    }
    sort(0,k-1);
    fun(k); 
}

P1991 无线通讯网

题目描述
国防部计划用无线网络连接若干个边防哨所。2 种不同的通讯技术用来搭建无线网络；
每个边防哨所都要配备无线电收发器；有一些哨所还可以增配卫星电话。
任意两个配备了一条卫星电话线路的哨所（两边都ᤕ有卫星电话）均可以通话，无论他们相距多远。而只通过无线电收发器通话的哨所之间的距离不能超过 � D，这是受收发器的功率限制。收发器的功率越高，通话距离 � D 会更远，但同时价格也会更贵。
收发器需要统一购买和安装，所以全部哨所只能选择安装一种型号的收发器。换句话说，每一对哨所之间的通话距离都是同一个 � D。你的任务是确定收发器必须的最小通话距离 � D，使得每一对哨所之间至少有一条通话路径（直接的或者间接的）。
输入格式
从 wireless.in 中输入数据第 1 行，2 个整数 � S 和 � P，� S 表示可安装的卫星电话的哨所数，� P 表示边防哨所的数量。接下里 � P 行，每行两个整数 �，� x， y 描述一个哨所的平面坐标 (�,�)( x, y)，以 km 为单位。
输出格式
输出 wireless.out 中
第 1 行，1 个实数 � D，表示无线电收发器的最小传输距离，精确到小数点后两位。
输入输出样例
输入 #1复制
2 4 0 100 0 300 0 600 150 750
输出 #1复制
212.13
说明/提示
对于 20%20% 的数据：�=2，�=1 P=2， S=1
对于另外 20%20% 的数据：�=4，�=2 P=4， S=2
对于 100%100% 的数据保证：1≤�≤1001≤ S≤100，�<�≤500 S< P≤500，0≤�,�≤100000≤ x, y≤10000。

1. 该题也是最小生成树问题，同样我采用了kruscal的算法。

2. 不同的是，之前我们做最小生成树的模板问题时，是遇见n-1条边时就可以退出了，但是这里的退出条件变成了p-s。

3. 在这个最小生成树中，最远的两点距离要根据s的数量，也就是说输出最小生成树里面边的排序第p-s条边的长度。因为s个可用电话，其他的都要用收发器，收发器的最大距离要能涵盖所有，最长的边要选用电话，这才是最优的方法。

4. 代码如下：

#include"stdio.h"
#include"math.h"
int f[100005],a[100005],b[100005];
int s,p,n,k;
double ans;
struct node
{
    double x,y,z;
}e[1000005];
int sort(int left,int right)
{
    int i=left,j=right;
    struct node t,k=e[left];
    if(left>=right) return 0;
    while(i<j)
    {
        while(i<j&&k.z<=e[j].z) j--;
        while(i<j&&k.z>=e[i].z) i++;
        if(i<j)
        {
            t=e[i];e[i]=e[j];e[j]=t;
        }
        e[left]=e[i];
        e[i]=k;
        sort(left,i-1);
        sort(i+1,right);
    }    
}
int find(int x)
{
    if(x!=f[x])
    f[x]=find(f[x]);
    return f[x];
}
void hb(int x,int y)
{
    int t1,t2;
    t1=find(x);
    t2=find(y);
    f[t1]=t2;
}
main()
{
    int i,j;
    scanf("%d %d",&s,&p);
    for(i=1;i<=p;i++)
    {
        scanf("%d %d",&a[i],&b[i]);
        for(j=1;j<i;j++)
        {
            n++;
            e[n].z=sqrt((a[i]-a[j])*(a[i]-a[j])+(b[i]-b[j])*(b[i]-b[j]));
            e[n].x=i;
            e[n].y=j;
        }
    }
    for(i=1;i<=p;i++)
    {
        f[i]=i;
    }
    sort(1,n);
    for(i=1;i<=n;i++)
    {
        if(find(e[i].x)!=find(e[i].y))
        {
            hb(e[i].x,e[i].y);
            ans=e[i].z;
            k++;
            if(k>=p-s)
            {
                printf("%.2lf",ans);
                return 0;
            }
        }
    }
}