寒假训练10最小生成树

已于 2024-05-11 22:48:20 修改
阅读量59 收藏
点赞数
分类专栏： 2021初学算法 文章标签： 图论
于 2021-01-31 12:32:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cggghh/article/details/113466068
版权

模板

prim

#include<stdio.h>
#include<algorithm>
using namespace std;
const int maxn=100010;
int set[maxn];
int mark[maxn];
int flag;
int dis[maxn];
struct node
{
    int a,b,l;
};
node dot[maxn];
bool cmp(node a,node b)
{
    return a.l<b.l;
}
int find(int x)
{
    return set[x]==x?set[x]:set[x]=find(set[x]);
}
void merge(int x,int y)
{
    int fx=find(x);
    int fy=find(y);
    if(fx!=fy)
        set[fy]=fx;
}
int main()
{
    int n,m;
    while(scanf("%d %d",&n,&m)!=EOF&&n)
    {
        int len=0;
        int count=0;
        for(int i=0;i<maxn;i++)
            set[i]=i;
        for(int i=0;i<n;i++)
        {
            scanf("%d %d %d",&dot[i].a,&dot[i].b,&dot[i].l);
        }
        sort(dot,dot+n,cmp);
        for(int i=0;i<n;i++)
        {
            if(find(dot[i].a)!=find(dot[i].b))
            {
                 merge(dot[i].a,dot[i].b);
                 len+=dot[i].l;
                 count++;
            }
        }
        if(count==m-1)
            printf("%d\n",len);
        else
            printf("?\n");
    }
    return 0;
}


#include<stdio.h>
#include<algorithm>
#include <cmath>
using namespace std;
const int maxn=100010;
int set[maxn];
int mark[maxn];
int flag;
int dis[maxn];
int a[maxn];
int b[maxn];
struct node
{
    int a,b;
    double l;
};
node dot[maxn];
bool cmp(node a,node b)
{
    return a.l<b.l;
}
int find(int x)
{
    return set[x]==x?set[x]:set[x]=find(set[x]);
}
void merge(int x,int y)
{
    int fx=find(x);
    int fy=find(y);
    if(fx!=fy)
        set[fy]=fx;
}
int main()
{
    int n,m,t,s;
    scanf("%d",&t);
    while(t--)
    {
    	scanf("%d",&n);
    	s=0;
        double len=0;
        int count=0;
        for(int i=0;i<maxn;i++)
            set[i]=i;
        for(int i=0;i<n;i++)
        {
            scanf("%d %d",&a[i],&b[i]);
        }
        for(int i=0;i<n;i++){
        	for(int j=0;j<n;j++){
        		double k=sqrt((a[i]-a[j])*(a[i]-a[j])+(b[i]-b[j])*(b[i]-b[j])*1.0);
        		if(k>=10&&k<=1000){
        			dot[s].a=i;
        			dot[s].b=j;
        			dot[s++].l=k;
				}
			}
		}
        sort(dot,dot+s,cmp);
        for(int i=0;i<s;i++)
        {
            if(find(dot[i].a)!=find(dot[i].b))
            {
                 merge(dot[i].a,dot[i].b);
                 len+=dot[i].l;
                 count++;
                 
            }
        }
        if(count==n-1)
            printf("%.1f\n",len*100);
        else
            printf("oh!\n");
    }
    return 0;
}

kruskal

#include<bits/stdc++.h>
using namespace std;
const int maxn = 110;
struct Edge{
    int u, v, w;
    bool operator < (const Edge &r)const{     //边权从小到大排序
        return w < r.w;
    }
}E[maxn * maxn];
int n, m, f[maxn];
int find(int x) {
    return x == f[x] ? x : f[x] = find(f[x]);
}
void Kruskal(int n, int m) {
    int res = 0;      // 存放结果
    int num = 0;      // 记录当前选择了多少条边
    sort(E + 1, E + 1 + m);
    for(int i = 1; i <= n; i++) f[i] = i;     //初始化 每个点自己为一个集合
    for(int i = 1; i <= m; i++) {
        int f1 = find(E[i].u);           //  查询u顶点在哪个集合中
        int f2 = find(E[i].v);           //  查询v顶点在哪个集合中
        if(f1 != f2) {                   //  如果不在同一个集合中
            num++;                       //  选中的边数 +1
            res += E[i].w;               //  答案加上这条边的权值
            f[f1] = f2;                  //  将这两个点合并到一个集合中
        }
        if(num == n - 1)                 // 如果已经找到了 n - 1条边，说明最小生成树已经构建完成了
            break;
    }
    if(num == n - 1) printf("%d\n", res);
    else  puts("?");
}
int main() {
    while(~scanf("%d %d", &m, &n)) {
        if(m == 0) break;
        for(int i = 1; i <= m; i++)
            scanf("%d%d%d", &E[i].u, &E[i].v, &E[i].w);
        Kruskal(n, m);
    }
    return 0;
}

例题

#include<stdio.h>
#include<algorithm>
#include <cmath>
using namespace std;
const int maxn=100010;
int set[maxn];
int mark[maxn];
int flag;
int dis[maxn];
int a[maxn];
int b[maxn];
struct node
{
    int a,b;
    int  l;
};
node dot[maxn];
bool cmp(node a,node b)
{
    return a.l<b.l;
}
int find(int x)
{
    return set[x]==x?set[x]:set[x]=find(set[x]);
}
void merge(int x,int y)
{
    int fx=find(x);
    int fy=find(y);
    if(fx!=fy)
        set[fy]=fx;
}
int main()
{
    int n,m,t,s,k;
    while(scanf("%d",&n)&&n){
    	s=0;
        int len=0;
        int count=0;
        for(int i=0;i<maxn;i++)
            set[i]=i;
        for(int i=0;i<n*(n-1)/2;i++)
        {
            scanf("%d %d %d %d",&dot[i].a,&dot[i].b,&dot[i].l,&k);
        if(k==1){
        	dot[i].l=0;
		}
	}
        sort(dot,dot+n*(n-1)/2,cmp);
        for(int i=0;i<n*(n-1)/2;i++)
        {
            if(find(dot[i].a)!=find(dot[i].b))
            {
                 merge(dot[i].a,dot[i].b);
                 len+=dot[i].l;
                 count++;
                 
            }
        }
            printf("%d\n",len);
}
    return 0;
}

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include <cmath>
using namespace std;
const int maxn=100010;
int set[maxn];
int mark[maxn];
int flag;
int dis[maxn];
int a[maxn];
int b[maxn];
struct node
{
    int a,b;
    int  l;
};
node dot[maxn];
bool cmp(node a,node b)
{
    return a.l<b.l;
}
int find(int x)
{
    return set[x]==x?set[x]:set[x]=find(set[x]);
}
void merge(int x,int y)
{
    int fx=find(x);
    int fy=find(y);
    if(fx!=fy)
        set[fy]=fx;
}
int main()
{
    int n,t,s;
    char k,m;
    while(scanf("%d",&n)!=EOF){
    	if(n==0)break;
    	s=0;
    	n--;
        int len=0;
        int count=0;
        for(int i=0;i<maxn;i++)
            set[i]=i;
            getchar();
        for(int i=0;i<n;i++)
        {
            cin>>k>>t;
            while(t--){
            	cin>>m>>dot[s].l;
            	dot[s].b=m-'A';
            	dot[s++].a=k-'A';
			}
	}
        sort(dot,dot+s,cmp);
        for(int i=0;i<s;i++)
        {
            if(find(dot[i].a)!=find(dot[i].b))
            {
                 merge(dot[i].a,dot[i].b);
                 len+=dot[i].l;
                 count++; 
            }
        }
            printf("%d\n",len);
}
    return 0;
}

判断是否多解

#include<stdio.h>
#include<algorithm>
#include <cmath>
using namespace std;
const int maxn=100010;
int set[maxn];
int mark[maxn];
int flag;
int dis[maxn];
int a[maxn];
int b[maxn];
struct node
{
    int a,b;
    int  l;
};
node dot[maxn];
bool cmp(node a,node b)
{
    return a.l<b.l;
}
int find(int x)
{
    return set[x]==x?set[x]:set[x]=find(set[x]);
}
void merge(int x,int y)
{
    int fx=find(x);
    int fy=find(y);
    if(fx!=fy)
        set[fy]=fx;
}
int main()
{
    int n,m,t,s,k;
    scanf("%d",&t);
    while(t--){
    	scanf("%d%d",&n,&m);
    	s=0;
        int len=0;
        int count=0;
        for(int i=0;i<maxn;i++)
            set[i]=i;
        for(int i=0;i<m;i++)
        {
            scanf("%d %d %d",&dot[i].a,&dot[i].b,&dot[i].l);
	}
        sort(dot,dot+m,cmp);
        for(int i=0;i<m;i++)
        {
            if(find(dot[i].a)!=find(dot[i].b))
            {
            	if(dot[i+1].l==dot[i].l){
            		if((dot[i+1].a==dot[i].a&&dot[i+1].b!=dot[i].b)||(dot[i+1].a==dot[i].b&&dot[i+1].b!=dot[i].a)||(dot[i+1].b==dot[i].a&&dot[i+1].a!=dot[i].b)||(dot[i+1].b==dot[i].b&&dot[i+1].a!=dot[i].a)){
            			if(find(dot[i+1].a!=find(dot[i+1].b)))
            			count++;
					}
				}
                 merge(dot[i].a,dot[i].b);
                 len+=dot[i].l;
                 
                 
            }
        }
        if(count==0)
            printf("%d\n",len);
            else
            printf("Not Unique!\n");
}
    return 0;
}

最大生成树

#include<stdio.h>
#include<algorithm>
#include <cmath>
using namespace std;
const int maxn=100010;
int set[maxn];
int mark[maxn];
int flag;
int dis[maxn];
int a[maxn];
int b[maxn];
struct node
{
    int a,b;
    int  l;
};
node dot[maxn];
bool cmp(node a,node b)
{
    return a.l>b.l;
}
int find(int x)
{
    return set[x]==x?set[x]:set[x]=find(set[x]);
}
void merge(int x,int y)
{
    int fx=find(x);
    int fy=find(y);
    if(fx!=fy)
        set[fy]=fx;
}
int main()
{
    int n,m,t,s,k;
    scanf("%d%d",&n,&m);
    	s=0;
        int len=0;
        int count=0;
        for(int i=0;i<maxn;i++)
            set[i]=i;
        for(int i=0;i<m;i++)
        {
            scanf("%d %d %d",&dot[i].a,&dot[i].b,&dot[i].l);
	}
        sort(dot,dot+m,cmp);
        for(int i=0;i<m;i++)
        {
            if(find(dot[i].a)!=find(dot[i].b))
            {
                 merge(dot[i].a,dot[i].b);
                 len+=dot[i].l;
                 count++;
                 
            }
        }
        if(count==n-1)
            printf("%d\n",len);
            else
            printf("-1\n");
    return 0;
}

bfs搜索＋最小生成树

#include<iostream>
#include<string>
using namespace std;
 
const int inf=2501;      //无限大,最大迷宫的总长也就2500
 
char map[51][51];  //迷宫原图
int node[51][51];   //记录当前格是否为字母，是第几个字母
int col,row;      //当前迷宫的行列数
int num;         //字母顶点数数目
int dist[102][102];      //构造结点图的两结点间权值，理论结点数最多为2500个（每一个允许通行的格为一个结点）
                         //但是POJ的数据库允许压缩到101个，哈哈，这样时间和空间复杂度都减少很多
int edge[102][102];      //构造字母图的两个字母间的边权，字母数最多为101
 
class move
{
 public:
	int row,col;
}mov[4]={{0,-1},{0,1},{-1,0},{1,0}}; //分别对应 上 下 左 右
 
void bfs(int i,int j)
{
	bool vist[51][51];  //标记当前迷宫某一格是否已被访问
	int que_x[2500],que_y[2500];  //坐标队列
	int head=0,tail=0;  //队列指针
 
	/*Initial*/
 
	memset(dist,0,sizeof(dist));
	memset(vist,false,sizeof(vist));
	vist[i][j]=true;
	que_x[tail]=i;
	que_y[tail++]=j;
 
	while(head<tail)
	{
		int x=que_x[head];
		int y=que_y[head++];
		if(node[x][y])
			edge[ node[i][j] ][ node[x][y] ] = dist[x][y];   //抽取字母到字母的边权
		for(int k=0;k<4;k++)
		{
			int mx=x+mov[k].row;
			int my=y+mov[k].col;
			if(mx>=1 && mx<= row && my>=1 && my<=col)
				if(!vist[mx][my] && map[mx][my]!='#')
				{
					que_x[tail]=mx;
					que_y[tail++]=my;
					vist[mx][my]=true;
					dist[mx][my]=dist[x][y]+1;
				}
		}
	}
	return;
}
 
int prim(void)
{
	int s=1;
	int m=1;
	bool u[102];
	u[s]=true;
 
	int min_w;
	int prim_w=0;
	int point;
	int low_dis[102];
 
	for(int i=1;i<=num;i++)
	{
		low_dis[i]=inf;
		u[i]=false;
	}
 
	while(true)
	{
		if(m==num)
			break;
 
		min_w=inf;
		for(int i=2;i<=num;i++)
		{
			if(!u[i] && low_dis[i]>edge[s][i])
				low_dis[i] = edge[s][i];
			if(!u[i] && min_w>low_dis[i])
			{
				min_w=low_dis[i];
				point=i;
			}
		}
		s=point;
		u[s]=true;
		prim_w+=min_w;
		m++;
	}
	return prim_w;
}
 
int main(int i,int j)
{
	int test;
	cin>>test;
	while(test--)
	{
		/*Initial*/
 
		memset(node,0,sizeof(node));
		num=0;
 
		/*Input*/
 
		cin>>col>>row;
		char temp[51];
		gets(temp);  //吃掉cin遗留下来的换行符,我不知道为什么getchar()会AW
		for(i=1;i<=row;i++)
		{
			gets(map[i]);
			for(j=1;j<=col;j++)
				if(map[i][j]=='A'||map[i][j]=='S')
					node[i][j]=++num;
		}
 
		/*BFS-> Structure Maps*/
 
		for(i=1;i<=row;i++)
			for(j=1;j<=col;j++)
				if(node[i][j])
					bfs(i,j);   //构造结点i,j到其他所有结点的边权（非#的格子就是一个结点）
 
		/*Prim Algorithm & Output*/
 
		cout<<prim()<<endl;
	}
	return 0;
}
SmallKa0
关注
专栏目录
暑假训练总结
G_Meteor的博客
08-26 346
不知不觉暑假就要这样结束了，这个假期主要在弄ACM了，但是由于家里原因并没有来学校参加集训，而是在家里跟着学知识点刷题做练习赛。   编程作为计算机的基础以及入门知识，其重要性自然不用说，而且大一刚开始就是学算法，当时感觉编程挺感兴趣的，然后参加那个新生编程赛。刚开始接触到ACM也是在这次新生编程比赛上吧，当时听到学长对ACM的介绍后，感觉挺感兴趣的，再加上当时感觉编程也是挺有意思的，然后大一寒
【python数据挖掘课程】二十七.基于SVM分类器的红酒数据分析
热门推荐
杨秀璋的专栏
01-16 1万+
这是《Python数据挖掘课程》系列文章，前面很多文章都讲解了分类、聚类算法，这篇文章主要讲解SVM分类算法，同时讲解如何读取TXT文件数据并进行数据分析及评价的过程。 文章比较基础，希望对你有所帮助，提供些思路，也是自己教学的内容。推荐大家购买作者新书《Python网络数据爬取及分析从入门到精通（分析篇）》，如果文章中存在错误或不足之处，还请海涵。 目录： 一.SVM基础概念 二.SVM基本使用方法 三.TXT红酒数据集预处理 四.SVM分析红酒数据 五.代码优化
《算法笔记上机实验指南》第4章 入门篇（2）---算法初步 4.6 two pointers
wsfhdhjs的博客
06-16 253
pat A1085 生词： 题意： 在一个数组中，满足max<=min*p的数组个数的最大值 输入： <fontcolor=#F0F8FF size=5 face=“黑体”> 1.输入n个数字和p 输出： 满足最大值<=最小值*P的序列中个数最多的个数 解题思路1： 1.设置n的上界maxn=100010，定义n,p,a[maxn]为全局变量 2.i,j分别表示前后遍历数组a的下标，根据题意可知a[j]<=a[i]*p，并且要求j-i最大 3.利用二分的思想：找出从i+
疯狂的采药（完全背包模板）
renxinyu2002的博客
11-01 293
#include #include #include #include using namespace std; const int maxn=100010; int f[maxn],n,t,h[maxn],v[maxn]; int main(){     scanf("%d%d",&t,&n);     for(int i=1;i     //for(int i=1;i
HDU6370 Werewolf【并查集】
qq_41989228的博客
08-14 192
 晚点补题解 #include &lt;bits/stdc++.h&gt; using namespace std; const int MAXN = 100010; int tot,head[MAXN],q[MAXN],f[MAXN]; bool vis[MAXN]; char str[10]; struct data { int x, role; } a[MAXN]; struct...
(C++)1045 快速排序 非满分
行步至春深
04-11 238
#include<cstdio> const int maxn=100010; //思路，从第一个元素开始，假设其是主元，然后用two pointers方法，看有没有进行交换，进行了则不是 int main(){ int iszy[maxn]={0};//0表示可以是主元，1表示一定不是 int num[maxn]={0};//用来存数据 int n; scanf("%d",&n); for(int i=0;i<n;i++){ scanf("%d",&a
PAT a1037题解
Tang's学习笔记
07-19 291
#include #include using namespace std; const int maxn = 100010; int coupon[maxn], product[maxn]; int main(){ int n, m; scanf("%d", &n); for(int i = 0; i < n; i++){ scanf("%d", &coupon[i]); }
天池龙珠计划寒假训练营学习笔记：利用XGBoost进行分析的完整流程
AI_SupplyChain的博客
01-29 636
天池龙珠计划寒假训练营学习笔记：利用XGBoost进行分析的完整步骤 工具：天池NoteBook 训练数据10.9MB 训练数据下载链接：https://tianchi-media.oss-cn-beijing.aliyuncs.com/DSW/7XGBoost/train.csv 声明： 本文主要内容来源于天池龙珠计划寒假训练营教材，部分内容有修改。 原文地址： 添加链接描述 1、XGBoost 的优缺点： 1.1 XGBoost的主要优点： 简单易用。相对其他机器学习库，用户可以轻松使用XGBoost
牛客网 2018年全国多校算法寒假训练营练习比赛（第四场） 题解
Daioo 随笔
02-11 510
A-石油采集 随着海上运输石油泄漏的问题，一个新的有利可图的行业正在诞生，那就是撇油行业。 B-道路建设 随着如今社会的不断变化，交通问题也变得越来越重要，所以市长决定建设一些公路来方便各个城市之间的贸易和交易。 C-求交集 给你两个升序排列的集合，求出两个集合的交集。 E-通知小弟 在战争时期，A国派出了许多间谍到其他国家去收集情报。 F-Call to your teacher 从实验室出来后，你忽然发现你居
ICPC训练联盟2021寒假冬令营(7)_2021.01.26_笔记
qq_19403405的博客
01-26 552
试题链接 点我进入代码提交OJ 学习笔记 - C++STL、贪心算法 C++STL 迭代器 要访问顺序容器和关联容器中的元素，需要通过迭代器（iterator）进行。迭代器是一个变量，相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素，通过迭代器就可以读写它指向的元素。迭代器和指针类似。迭代器按照定义方式分成正向迭代器、常量正向迭代器、反向迭代器和常量反向迭代器四种。正向迭代器的定义方式为：“容器类名::iterator 迭代器名；”。 STL算法 算法，是编程解决问题的方法。STL提供了
Codeforces Round #350 (Div. 2) (二分答案)
I good vegetable a!
05-06 466
【题意】给了n个物品和k，a[i]表示做成第i个物品需要的材料，b[i]表示当前第i种物品的材料重量。k代表可以在任意一种物品，或者多个添加该种物品的不定重量，最后求可以合成的最多的物品数。 【分析】裸二分答案，就是数据范围有点坑，还要注意二分的姿势，二分最近总是写错，以前还没有错过。 【AC代码】 #include using namespace std; #define ll long
C/C++[算法入门]
机器会学习的博客
06-03 573
B1001 害死人不偿命的(3n+1)猜想 卡拉兹(Callatz)猜想： 　　对任何一个自然数n，如果它是偶数，那么把它砍掉一半；如果它是奇数，那么把(3n+1)砍掉一半。这样一直反复砍下去，最后一定在某一步得到n=1。卡拉兹在1950年的世界数学家大会上公布了这个猜想，传说当时耶鲁大学师生齐动员，拼命想证明这个貌似很傻很天真的命题，结果闹得学生们无心学业，一心只证(3n+1)，以至于有人说...
PAT a1067题解
Tang's学习笔记
07-21 386
#include #include using namespace std; const int maxn = 100010; int pos[maxn]; int main(){ int n, ans = 0; scanf("%d", &n); int left = n -1, num; for(int i = 0; i < n; i++){ scanf("%d", &num
PAT 1090
好好学习，天天向上
02-26 345
#include #include #include #include #include #include #include #include using namespace std; const int maxn=100010; struct Node { int weight; vector child; }node[maxn]; int n; double p,r; double
pat 1067
说文科技，做有态度的研究。
01-07 485
1. 源代码 #include #include using namespace std; const int maxn = 100010; int pos[maxn];//存放各数字当前所处的位置编号 int main(){ int n,ans = 0; scanf("%d",&n); int left = n-1,num;//left表示除0以外不在本位上的个数 for(int
c语言中const的作用
weixin_39580537的博客
06-03 620
我们在平时编码的过程中，有时候会定义一个变量，希望这个变量的值不能被改变，在整个作用域中都保持固定，我们就可以用const在这个作用域中去修饰这个变量。 constint MaxNum=100;//班级的最大人数 ...
C语言 关键字const的作用
WhiteShirtI的博客
11-14 9165
关键词解释 const是一个C语言（ANSI C）的关键字，具有着举足轻重的地位。它限定一个变量不允许被改变，产生静态作用。使用const在一定程度上可以提高程序的安全性和可靠性。另外，在观看别人代码的时候，清晰理解const所起的作用，对理解对方的程序也有一定帮助。 定义 const修饰的数据类型是指常类型，常类型的变量或对象的值是不能被更新的。 主要作用 1、可以定义const常量，具有不可变性 2、便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。例如： void f(const int
算法笔记配套题 codeup100000582 问题 A: 谁是你的潜在朋友
weixin_44211856的博客
02-14 183
#include <cstdio> const int maxn=100010; int hashTable[maxn]={0}; int p[maxn]={0}; int main(){ int n=0,m=0,x=0; while(scanf("%d %d",&n,&m)!=EOF){ for(int i=0;i<m;i++){ hashTab...
划分树
逐梦者
07-20 1583
ACM模版划分树/* * 划分树(查询区间第k大) */ const int MAXN = 100010;int tree[20][MAXN]; // 表示每层每个位置的值 int sorted[MAXN]; // 已经排序好的数 int toleft[20][MAXN]; // toleft[p][i]表示第i层从1到i有数分入左边void build(int
硬禾平台寒假训练营：网络时间与天气显示项目
资源摘要信息:"本项目是硬禾平台2022寒假训练营中的第六个实践项目，旨在教授如何利用OLED显示屏、时间API和天气API来显示网络时间与天气情况。通过本项目，学习者将深入了解嵌入式系统的设计与编程，特别是对于STM...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值