2022.2.16（最小生成树）

STATICHIT静砸

已于 2022-03-05 15:28:27 修改

阅读量754

点赞数

分类专栏：数据结构&算法各种总结文章标签：算法图论蓝桥杯

于 2022-02-16 23:12:08 首次发布

本文链接：https://blog.csdn.net/m0_62742402/article/details/122961974

版权

各种总结同时被 2 个专栏收录

92 篇文章 0 订阅

订阅专栏

数据结构&算法

54 篇文章 0 订阅

订阅专栏

c++中sort的重载
文件操作在vs2019中遇到了困难（想办法ing）
做题⬇⬇⬇

P3366 【模板】最小生成树

题目描述

如题，给出一个无向图，求出最小生成树，如果该图不连通，则输出 orz。

输入格式

第一行包含两个整数 N,MN,M，表示该图共有 NN 个结点和 MM 条无向边。

接下来 MM 行每行包含三个整数 X_i,Y_i,Z_iXi,Yi,Zi，表示有一条长度为 Z_iZi 的无向边连接结点 X_i,Y_iXi,Yi。

输出格式

如果该图连通，则输出一个整数表示最小生成树的各边的长度之和。如果该图不连通则输出 orz。

输入输出样例

输入 #1复制
4 5
1 2 2
1 3 2
1 4 3
2 3 4
3 4 3
输出 #1复制
7
说明/提示

数据规模：

对于 20\%20% 的数据，N\le 5N≤5，M\le 20M≤20。

对于 40\%40% 的数据，N\le 50N≤50，M\le 2500M≤2500。

对于 70\%70% 的数据，N\le 500N≤500，M\le 10^4M≤104。

对于 100\%100% 的数据：1\le N\le 50001≤N≤5000，1\le M\le 2\times 10^51≤M≤2×105，1\le Z_i \le 10^41≤Zi≤104。

样例解释：

所以最小生成树的总边权为 2+2+3=72+2+3=7。
#include<bits/stdc++.h>
using namespace std;

const int N=5001;
const int M=200001;
int n,m,x,y,z;
int f[N],sum,num;//并查父亲集数组,总代价,边数

struct EDGE
{
    int a,b,v;
}e[M];//用结构体数组存储边的关系，便于排序

bool cmp(EDGE a,EDGE b)
{
    return a.v<b.v;//实现根据v从小到大排序
}

int getf(int i)//并查集找祖宗函数
{
    if(f[i] == i)
        return i;
    else
        return f[i]=getf(f[i]);//压缩路径
}

int hebing(int a,int b)
{
    if( getf(a) != getf(b) )
    {
        f[getf(b)]=getf(a);
        return 1;//说明两参数顶点不在一棵树上,选他，然后把他们合并成一棵树
    }
    else
    return 0;//说明两参数顶点在同一棵树上，会成环，丢弃
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)//结构体存边
    {
        cin>>x>>y>>z;
        e[i].a=x;e[i].b=y;e[i].v=z;
    }
    sort(e+1,e+1+m,cmp);//按照权值排序边
    //初始化并查集
    for(int i=1;i<=n;i++)
        f[i]=i;
    //Kruskal
    for(int i=1;i<=m;i++)
    {
        //判断该边链接的两个顶点是否在一颗树上
        if( hebing(e[i].a,e[i].b) == 1)
        {
            hebing(e[i].a,e[i].b);
            num++;//边数加一
            sum+=e[i].v;
        }
        if(num == n-1)break;//选了n-1条边了就退出
    }
    if(num < n-1)
       cout<<"orz"<<endl;
    else
       cout<<sum<<endl;//输出最小代价
}

P1991 无线通讯网

题目描述

国防部计划用无线网络连接若干个边防哨所。2 种不同的通讯技术用来搭建无线网络；

每个边防哨所都要配备无线电收发器；有一些哨所还可以增配卫星电话。

任意两个配备了一条卫星电话线路的哨所（两边都ᤕ有卫星电话）均可以通话，无论他们相距多远。而只通过无线电收发器通话的哨所之间的距离不能超过 DD，这是受收发器的功率限制。收发器的功率越高，通话距离 DD 会更远，但同时价格也会更贵。

收发器需要统一购买和安装，所以全部哨所只能选择安装一种型号的收发器。换句话说，每一对哨所之间的通话距离都是同一个 DD。你的任务是确定收发器必须的最小通话距离 DD，使得每一对哨所之间至少有一条通话路径（直接的或者间接的）。

输入格式

从 wireless.in 中输入数据第 1 行，2 个整数 SS 和 PP，SS 表示可安装的卫星电话的哨所数，PP 表示边防哨所的数量。接下里 PP 行，每行两个整数 x，yx，y 描述一个哨所的平面坐标 (x, y)(x,y)，以 km 为单位。

输出格式

输出 wireless.out 中

第 1 行，1 个实数 DD，表示无线电收发器的最小传输距离，精确到小数点后两位。

输入输出样例

输入 #1复制
2 4
0 100
0 300
0 600
150 750
输出 #1复制
212.13
说明/提示

对于 20\%20% 的数据：P = 2，S = 1P=2，S=1

对于另外 20\%20% 的数据：P = 4，S = 2P=4，S=2

对于 100\%100% 的数据保证：1 ≤ S ≤ 1001≤S≤100，S < P ≤ 500S<P≤500，0 ≤ x,y ≤ 100000≤x,y≤10000。
//就是要最小代价生成s个集合，其中有4个顶点，权值即距离要自己算
#include<bits/stdc++.h>
using namespace std;
int s,p;//p为哨所数量（顶点数）
int a,b,x[510],y[510];
int f[501],num;//num为集合数

struct EDGE
{
    int a,b;
    double v;
}e[250001];//范围要大于500*500用结构体数组存储边的关系，便于排序

bool cmp(EDGE a,EDGE b)
{
    return a.v<b.v;//实现根据v从小到大排序
}

int getf(int i)//并查集找祖宗函数
{
    if(f[i] == i)
        return i;
    else
        return f[i]=getf(f[i]);//压缩路径
}

int hebing(int a,int b)
{
    if( getf(a) != getf(b) )
    {
        f[getf(b)]=getf(a);
        return 1;//说明两参数顶点不在一棵树上,选他，然后把他们合并成一棵树
    }
    else
    return 0;//说明两参数顶点在同一棵树上，会成环，丢弃
}

double weight(int x,int y,int xx,int yy)//求两点距离即权值
{
    return sqrt((x - xx)*(x - xx) + (y - yy)*(y - yy));
}

int main()
{
    int i;
    cin>>s>>p;
    for(i=1;i<=p;i++)
    {
        f[i]=i;
        cin>>a>>b;
        x[i]=a;y[i]=b;
    }
    ///算权值,存边
    int k=0;
    for(i=1;i<=p;i++)
        for(int j=i+1;j<=p;j++)//这里j=i+1,避免重复存边，降低空间时间复杂度
    {
        k++;
        e[k].a=i;e[k].b=j;
        e[k].v=weight(x[i],y[i],x[j],y[j]);
    }

    sort(e+1,e+1+k,cmp);//按照权值排序边
    num=p;//集合数一开始等于结点数
    //Kruskal
    for(i=1;i<=k;i++)
    {
        //判断该边链接的两个顶点是否在一颗树上
        if( hebing(e[i].a,e[i].b) == 1)
        {
            hebing(e[i].a,e[i].b);
            num--;
        }
        if(num == s)break;//当集合数等于s时结束，剩下的集合可以用s个无线电收发器连接
    }
       printf("%.2 lf", e[i].v);//第i条边的长度即为最小值
}

P2121 拆地毯

题目背景

还记得 NOIP 2011 提高组 Day1 中的铺地毯吗？时光飞逝，光阴荏苒，三年过去了。组织者精心准备的颁奖典礼早已结束，留下的则是被人们踩过的地毯。请你来解决类似于铺地毯的另一个问题。

题目描述

会场上有 n 个关键区域，不同的关键区域由 m 条无向地毯彼此连接。每条地毯可由三个整数 u、v、w 表示，其中 u 和 v 为地毯连接的两个关键区域编号，w 为这条地毯的美丽度。

由于颁奖典礼已经结束，铺过的地毯不得不拆除。为了贯彻勤俭节约的原则，组织者被要求只能保留 K 条地毯，且保留的地毯构成的图中，任意可互相到达的两点间只能有一种方式互相到达。换言之，组织者要求新图中不能有环。现在组织者求助你，想请你帮忙算出这 K 条地毯的美丽度之和最大为多少。

输入格式

第一行包含三个正整数 n、m、K。

接下来 m 行中每行包含三个正整数 u、v、w。

输出格式

只包含一个正整数，表示这 K 条地毯的美丽度之和的最大值。

输入输出样例

输入 #1复制
5 4 3
1 2 10
1 3 9
2 3 7
4 5 3
输出 #1复制
22
说明/提示

选择第 1、2、4 条地毯，美丽度之和为 10 + 9 + 3 = 22。

若选择第 1、2、3 条地毯，虽然美丽度之和可以达到 10 + 9 + 7 = 26，但这将导致关键区域 1、2、3 构成一个环，这是题目中不允许的。

1<=n,m,k<=100000
#include<bits/stdc++.h>
using namespace std;

const int N=100001;
int n,m,x,y,z,k;
int f[N],sum,num;//并查父亲集数组,总代价,边数

struct EDGE
{
    int a,b,v;
}e[N];//用结构体数组存储边的关系，便于排序

bool cmp(EDGE a,EDGE b)
{
    return a.v>b.v;//实现根据v从大到小排序
}

int getf(int i)//并查集找祖宗函数
{
    if(f[i] == i)
        return i;
    else
        return f[i]=getf(f[i]);//压缩路径
}

int hebing(int a,int b)
{
    if( getf(a) != getf(b) )
    {
        f[getf(b)]=getf(a);
        return 1;//说明两参数顶点不在一棵树上,选他，然后把他们合并成一棵树
    }
    else
    return 0;//说明两参数顶点在同一棵树上，会成环，丢弃
}

int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=m;i++)//结构体存边
    {
        cin>>x>>y>>z;
        e[i].a=x;e[i].b=y;e[i].v=z;
    }
    sort(e+1,e+1+m,cmp);//按照权值排序边
    //初始化并查集
    for(int i=1;i<=n;i++)
        f[i]=i;
    //Kruskal
    for(int i=1;i<=m;i++)
    {
        //判断该边链接的两个顶点是否在一颗树上
        if( hebing(e[i].a,e[i].b) == 1)
        {
            hebing(e[i].a,e[i].b);
            num++;//边数加一
            sum+=e[i].v;
        }
        if(num == k)break;//选了k条边了就退出
    }

       cout<<sum;//输出最大代价
}

P1195 口袋的天空

题目背景

小杉坐在教室里，透过口袋一样的窗户看口袋一样的天空。

有很多云飘在那里，看起来很漂亮，小杉想摘下那样美的几朵云，做成棉花糖。

题目描述

给你云朵的个数 NN，再给你 MM 个关系，表示哪些云朵可以连在一起。

现在小杉要把所有云朵连成 KK 个棉花糖，一个棉花糖最少要用掉一朵云，小杉想知道他怎么连，花费的代价最小。

输入格式

第一行有三个数 N,M,KN,M,K。

接下来 MM 行每行三个数 X,Y,LX,Y,L，表示XX云和 YY 云可以通过 LL 的代价连在一起。

输出格式

对每组数据输出一行，仅有一个整数，表示最小的代价。

如果怎么连都连不出 KK 个棉花糖，请输出 No Answer。

输入输出样例

输入 #1复制
3 1 2
1 2 1
输出 #1复制
1
说明/提示

对于 30\%30% 的数据，N \le 100N≤100，M \le 10^3M≤103；

对于 100\%100% 的数据，1 \le N \le 10^31≤N≤103，1 \le M \le 10^41≤M≤104，1 \le K \le 101≤K≤10，1 \le X,Y \le N1≤X,Y≤N，0 \le L<10^40≤L<104。
#include<bits/stdc++.h>
using namespace std;

const int N=1001;
const int M=10001;
int n,m,x,y,z,k;
int f[N],sum,num;//并查父亲集数组,总代价,边数

struct EDGE
{
    int a,b,v;
}e[M];//用结构体数组存储边的关系，便于排序

bool cmp(EDGE a,EDGE b)
{
    return a.v<b.v;//实现根据v从小到大排序
}

int getf(int i)//并查集找祖宗函数
{
    if(f[i] == i)
        return i;
    else
        return f[i]=getf(f[i]);//压缩路径
}

int hebing(int a,int b)
{
    if( getf(a) != getf(b) )
    {
        f[getf(b)]=getf(a);
        return 1;//说明两参数顶点不在一棵树上,选他，然后把他们合并成一棵树
    }
    else
    return 0;//说明两参数顶点在同一棵树上，会成环，丢弃
}

int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=m;i++)//结构体存边
    {
        cin>>x>>y>>z;
        e[i].a=x;e[i].b=y;e[i].v=z;
    }
    sort(e+1,e+1+m,cmp);//按照权值排序边
    //初始化并查集
    for(int i=1;i<=n;i++)
        f[i]=i;
    //Kruskal
    num=n;//初始时集合数即顶点数
    for(int i=1;i<=m;i++)
    {
        //判断该边链接的两个顶点是否在一颗树上
        if( hebing(e[i].a,e[i].b) == 1)
        {
            hebing(e[i].a,e[i].b);
            num--;//边数加一
            sum+=e[i].v;
        }
        if(num == k)break;//形成了k个集合就退出
    }

       cout<<sum;//输出最小代价
}

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.

给定 nn 个点的坐标，第 ii 个点的坐标为 (x_i,y_i)(xi,yi)，这 nn 个点编号为 11 到 nn。给定 mm 条边，第 ii 条边连接第 u_iui 个点和第 v_ivi 个点。现在要求你添加一些边，并且能使得任意一点都可以连通其他所有点。求添加的边的总长度的最小值。

输入格式

* 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,mn,m 代表点数与边数。
接下来 nn 行每行两个整数 x_i,y_ixi,yi 代表第 ii 个点的坐标。
接下来 mm 行每行两个整数 u_i,v_iui,vi 代表第 ii 条边连接第 u_iui 个点和第 v_ivi 个点。

输出格式

* 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 \le n,m \le 10001≤n,m≤1000，1 \le x_i,y_i \le 10^61≤xi,yi≤106，1 \le u_i,v_i \le n1≤ui,vi≤n。
#include<bits/stdc++.h>
using namespace std;

int n,m,p,q;
double x[1001],y[1001];//用double类型方便权值计算
int f[1001],num;
double sum=0;

struct EDGE
{
    int a,b;
    double v;
} e[1000001];

bool cmp(EDGE a,EDGE b)
{
    return a.v<b.v;
}

int getf(int i)
{
    if(f[i] == i)
        return i;
    else
        return f[i]=getf(f[i]);
}

void hebing(int x,int y)
{
    if( getf(x) != getf(y) )
        f[getf(y)]=getf(x);
}

//因为数据范围很大，要严格控制精度
double weight(double x,double y,double xx,double yy)
{
  return sqrt((x-xx)*(x-xx)+(y-yy)*(y-yy));
}

int main()
{
    cin>>n>>m;
    num=m;//已经有m条边了

    for(int i=1; i<=n; i++)
    {
        f[i]=i;//蹭一下循环来初始化并查集
        scanf("%lf%lf",&x[i],&y[i]);
    }

    int k=0;//总边数
    for(int i=1;i<=n;i++)
        for(int j=i+1;j<=n;j++)//这里j=i+1,避免重复存边，降低空间时间复杂度
    {
        k++;
        e[k].a=i;e[k].b=j;
        e[k].v=weight(x[i],y[i],x[j],y[j]);
    }
    sort(e+1,e+1+k,cmp);
    while(m--)
    {
        cin>>p>>q;
        hebing(p,q);
    }
    //kruskal
    for(int i=1;i<=k;i++)
    {
        if( getf(e[i].a) != getf(e[i].b) )
        {
            hebing(e[i].a,e[i].b);//别忘了合并哦
            num++;
            sum+=e[i].v;
        }
        if(num == n-1)break;
    }
    printf("%.2lf",sum);
        return 0;
}