2022.2.17（最小生成树题目）-CSDN博客

#include<bits/stdc++.h> 
using namespace std;
int n,m,k,total;
struct edge{
    int start;
	int to;
	int val;
}bian[2000000];
int f[1000000];
int ans;
int find(int x)//并查集部分
{
    if (f[x]==x) 
		return x; 
	else 
    {
        f[x]=find(f[x]);
        return f[x];
    }	
}

bool cmp(edge a,edge b)//结构体快排,这个排法太赞了！！ 
{
    return a.val>b.val;
}

void kruskal()//最小生成树
{
    for(int i=1;i<=m;i++)
    {
    	int u,v; 
        u=find(bian[i].start);
        v=find(bian[i].to);
        if(u==v)
			continue;//判断在不在同一个并查集里面，在就跳过这次循环
        ans+=bian[i].val;//不在，就加起来 
        f[u]=v;//合并两个并查集
        	total++;
        if(total==k) 
			break;//当形成了最小生成树后，退出（之后做的也没用了）
    }
} 
int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++) 
		f[i]=i;//初始化父节点为自己 
    for(int i=1;i<=m;i++)
    {
        cin>>bian[i].start>>bian[i].to>>bian[i].val;
    }
    sort(bian+1,bian+m+1,cmp);//排序边长
    kruskal();
   	cout<<ans;
    return 0;
}

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复制

说明/提示

对于 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。

思路

1、如果n个点被n-1条边连接的话，这一定是棵树

2、

那么：

连的边数得到的树的个数

n-1 1

n-2 2

n-3 3

... ...

n-k k

3、所以我们如果想要连出k棵树，就需要连n-k条边

代码

#include<bits/stdc++.h> 
using namespace std;
int n,m,k,total;
struct edge{
    int start;
	int to;
	int val;
}bian[2000000];
int f[1000000];
int ans;
int find(int x)//并查集部分
{
    if (f[x]==x) 
		return x; 
	else 
    {
        f[x]=find(f[x]);
        return f[x];
    }	
}

bool cmp(edge a,edge b)//结构体快排,这个排法太赞了！！ 
{
    return a.val<b.val;
}

void kruskal()//最小生成树
{
    for(int i=1;i<=m;i++)
    {
    	int u,v; 
        u=find(bian[i].start);
        v=find(bian[i].to);
        if(u==v)
			continue;//判断在不在同一个并查集里面，在就跳过这次循环
        ans+=bian[i].val;//不在，就加起来 
        f[u]=v;//合并两个并查集
        	total++;
        if(total==n-k) 
			break;//当形成了最小生成树后，退出（之后做的也没用了）
    }
} 
int main()
{
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++) 
		f[i]=i;//初始化父节点为自己 
    for(int i=1;i<=m;i++)
    {
        cin>>bian[i].start>>bian[i].to>>bian[i].val;
    }
    sort(bian+1,bian+m+1,cmp);//排序边长
    kruskal();
    if(total==n-k)
    	cout<<ans;
    else  cout<<"No Answer";
    return 0;
}

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复制

输出 #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。

说明

Translated by 一只书虫仔。

思路

1、先对每一个点记录坐标

2、对每两个点都进行距离运算(其实只用运算一次就够了，不管A到B还是B到A都是一样长)

3、把已经建好的路的价值改成0
4、进行kruskal运算(先按价值排序，然后并查集将所有点连在一棵树上，输出连起来所用的价值和)

5、易错点（害我调试很久的点）：
①两点距离公式，在平方的时候要强转double
如：sqrt((double)(x-a.x)*(double)(x-a.x)+(double)(y-a.y)*(double)(y-a.y))

②数组要开6个0！！！记住了吗！！

代码

#include<bits/stdc++.h> 
using namespace std;
int s,p,n,total,a[1000000],b[1000000];
struct edge{
    int start;
	int to;
	double val;
}bian[2000000];
int f[1000000];
double ans=0.0;
int find(int x)//并查集部分
{
    if (f[x]==x) 
		return x; 
	else 
    {
        f[x]=find(f[x]);
        return f[x];
    }	
}

bool cmp(edge a,edge b)//结构体排序,这个排法太赞了！！ 
{
    return a.val<b.val;
}

void kruskal()//最小生成树
{
    for(int i=1;i<=n;i++)
    {
    	int u,v; 
        u=find(bian[i].start);
        v=find(bian[i].to);
        if(u==v)
			continue;//判断在不在同一个并查集里面，在就跳过这次循环
        ans+=bian[i].val;//不在，就加起来
		f[u]=v;//合并两个并查集
        total++;
        if(total==s-1) 
			break;//当形成了最小生成树后，退出（之后做的也没用了）
    }
} 
int main()
{
    cin>>s>>p;
    for(int i=1;i<=s;i++) 
		f[i]=i;//初始化父节点为自己 
    for(int i=1;i<=s;i++)//存图 !!
    {
    	cin>>a[i]>>b[i];
    	for(int j=1;j<i;j++)
    	{
    		n++;
    		bian[n].start=i;
    		bian[n].to=j;
    		bian[n].val =sqrt((double)(a[i]-a[j])*(double)(a[i]-a[j])+(double)(b[i]-b[j])*(double)(b[i]-b[j]));
		}
	}
	while(p--)
	{
		cin>>a[++n]>>b[n];
		bian[n].start=a[n];
    	bian[n].to=b[n];
    	bian[n].val =0.0;
	}
    sort(bian+1,bian+n+1,cmp);//排序边长
    kruskal();
    printf("%.2lf",ans);
    return 0;
}