最小生成树(poj1251 poj1861 poj1789)

最新推荐文章于 2020-07-13 20:31:37 发布
最新推荐文章于 2020-07-13 20:31:37 发布
阅读量402 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woxiaohahaa/article/details/48844869
版权

1. Prim算法

该算法与Dijkstra算法十分相似，不同的地方在于Dist矩阵的算法有细微差别。见下面的实现：

/*
poj 1251
time: 0ms
memory:220k
PS：该题目的输入中每行结尾可能有几个空格，要是用scanf函数，字符串的输入要用字符数组，而不能用单个字符。或者用cin输入。
*/
#include <iostream>
using namespace std;

#define MaxNode 27
#define MaxEdge 150
#define INF 1000000


struct VertexEntry
{
	int next, e, cost;
};

VertexEntry vertex[MaxEdge + MaxNode]; 
int Cost[MaxNode];
int Path[MaxNode];
int Known[MaxNode];

void Init(int Num)
{
	int i, j, k = Num + 1, cost, num;
	char id;

	for(i = 1; i <= Num; ++i)
	{
		Cost[i] = INF;
		Path[i] = 0;
		Known[i] = 0;
		vertex[i].next = 0;
	}
	Cost[1] = 0;

	while(--Num)
	{
		cin >> id >> num;
		i = id - '@';
		while(num--)
		{
			cin >> id >> cost;
			j = id - '@';
			vertex[k].cost = cost;
			vertex[k].e = j;
			vertex[k].next = vertex[i].next;
			vertex[i].next = k++;

			vertex[k].cost = cost;
			vertex[k].e = i;
			vertex[k].next = vertex[j].next;
			vertex[j].next = k++;			
		}
	}
}

int Prim(int Num)
{
	int i, j, min, sum = 0;

	while(1)
	{
		min = INF;
		for(i = 1; i <= Num; ++i)
		{
			if(!Known[i] && Cost[i] < min)
			{
				min = Cost[i];
				j = i;
			}
		}
		if(min == INF)
			break;
		
		Known[j] = 1;

		i = j;
		while(vertex[j].next)
		{
			j = vertex[j].next;
			if(!Known[vertex[j].e] && vertex[j].cost < Cost[vertex[j].e])
			{
				Cost[vertex[j].e] = vertex[j].cost;
				Path[vertex[j].e] = i;
			}
		}
	}
	for(i = 1; i <= Num; ++i)
	{
		sum += Cost[i];
	}
	return sum;
}

int main()
{
	int Num;
	cin >> Num;
	while(Num)
	{
		Init(Num);
		cout << Prim(Num) << endl;		
		cin >> Num;
	}
	return 0;
}

PS：开始我使用scanf搭配char，一直不过，一查才知道数据输入可能每行结尾有多余的空格。虽然空格、制表符和新行符都用做域分割符号，但读单字符操作中却按一般字符处理。例如，对输入流 "x y" 调用：

scanf("%c%c%c",&a,&b,&c);  //x 在变量 a 中，空格在变量 b 中，y 在变量 c 中

使用scanf则要与char[]搭配才行，如下代码：

/*
poj 1251
time: 0ms
memory: 220k
*/
#include <iostream>
#include <stdio.h>
using namespace std;

#define MaxNode 27
#define MaxEdge 150
#define INF 1000000


struct VertexEntry
{
	int next, e, cost;
};

VertexEntry vertex[MaxEdge + MaxNode]; 
int Cost[MaxNode];
int Path[MaxNode];
int Known[MaxNode];

void Init(int Num)
{
	int i, j, k = Num + 1, cost, num;
	char id[3];			//注意此处

	for(i = 1; i <= Num; ++i)
	{
		Cost[i] = INF;
		Path[i] = 0;
		Known[i] = 0;
		vertex[i].next = 0;
	}
	Cost[1] = 0;

	while(--Num)
	{
		scanf("%s%d", id, &num);
		i = id[0] - '@';		//注意此处
		while(num--)
		{
			scanf("%s%d", id, &cost);	//注意此处
			j = id[0] - '@';
			vertex[k].cost = cost;
			vertex[k].e = j;
			vertex[k].next = vertex[i].next;
			vertex[i].next = k++;

			vertex[k].cost = cost;
			vertex[k].e = i;
			vertex[k].next = vertex[j].next;
			vertex[j].next = k++;			
		}
	}
}

int Prim(int Num)
{
	int i, j, min, sum = 0;

	while(1)
	{
		min = INF;
		for(i = 1; i <= Num; ++i)
		{
			if(!Known[i] && Cost[i] < min)
			{
				min = Cost[i];
				j = i;
			}
		}
		if(min == INF)
			break;
		
		Known[j] = 1;

		i = j;
		while(vertex[j].next)
		{
			j = vertex[j].next;
			if(!Known[vertex[j].e] && vertex[j].cost < Cost[vertex[j].e])
			{
				Cost[vertex[j].e] = vertex[j].cost;
				Path[vertex[j].e] = i;
			}
		}
	}
	for(i = 1; i <= Num; ++i)
	{
		sum += Cost[i];
	}
	return sum;
}	

int main()
{
	int Num;
	cin >> Num;
	while(Num)
	{
		Init(Num);
		cout << Prim(Num) << endl;		
		cin >> Num;
	}
	return 0;
}


2. Kruskal算法

kruskal算法总共选择n- 1条边，（共n个点）所使用的贪婪准则是：从剩下的边中选择一条不会产生环路的具有最小耗费的边加入已选择的边的集合中。注意到所选取的边若产生环路则不可能形成一棵生成树。该算法常与并查集，最小堆联合使用。与prim算法像比较，kruskal算法适用于稠密图，而prim算法对稀疏图和稠密图都较适用，原因就在于边的权的存储方式的不同。kruskal算法常用用结构数组将边存储，而prim算法既可以用二维数组（邻接矩阵）存储边的信息，也可以用邻接表存储。

/*
poj 1861
time: 16ms
memory:428k
*/
#include <iostream>
#include <stdio.h>
using namespace std;


#define MaxNode 1001
#define MaxEdge 15001


typedef int PriorityQueue[MaxEdge];
typedef int DisjSet[MaxNode];




struct EdgeEntry
{
	int n1, n2, w, flag;
};


DisjSet s;					//并查集
EdgeEntry Edge[MaxEdge];
PriorityQueue H;				//最小堆，H[i],i表示在堆里的位置，H[i]是指向Edge的index，通过改变H[i]的取值完成堆的实现
int max_w = 0;					//存储选中边里的最大权值


void Init(int N, int M)
{
	int i, n1, n2, w;
	for(i = 1; i <= N; ++i)
	{
		s[i] = -1;
	}


	for(i = 1; i <= M; ++i)
	{
		scanf("%d%d%d", &n1, &n2, &w);
		Edge[i].n1 = n1;
		Edge[i].n2 = n2;
		Edge[i].w = w;
		Edge[i].flag = 0;
		H[i] = i;			//此处对H[i]初始化，相当于将Edge按顺序放入堆里
	}
}


int Find(int v)
{
	if(s[v] < 0)
		return v;
	else
		return s[v] = Find(s[v]);
}


void Union(int root1, int root2)
{
	if(s[root1] < s[root2])
	{
		s[root1] += s[root2];
		s[root2] = root1;
	}		
	else
	{
		s[root2] += s[root1];
		s[root1] = root2;
	}
}


void PercolateDown(int M, int i)
{	
	int FirstElement = H[i];
	int child;
	for(; 2 * i <= M; i = child)
	{
		child = 2 * i;
		if(2 * i + 1 <= M && Edge[H[2 * i + 1]].w < Edge[H[2 * i]].w)
			++child;
		if(Edge[H[child]].w < Edge[FirstElement].w)		//务必注意此处，使用FirstElement而不是H[i],虽然容易理解，但也很容易犯错
			H[i] = H[child];
		else
			break;
	}
	H[i] = FirstElement;
}


int DeleteMin(int M)
{
	int i, child;
	int MinElement = H[1];
	int LastElement = H[M];


	for(i = 1; i * 2 <= M; i = child)
	{
		child = 2 * i;
		if(2 * i + 1 <= M && Edge[H[2 * i + 1]].w < Edge[H[i * 2]].w)
			++child;
		if(Edge[LastElement].w > Edge[H[child]].w)		//务必注意此处，使用LastElement而不是H[i]
			H[i] = H[child];
		else
			break;
	}
	H[i] = LastElement;
	return MinElement;
}


void Kruskal(int N, int M)
{
	int cnt = 0;
	int root1, root2;
	int Edgeid;
	
	while(cnt < N - 1)
	{
		Edgeid = DeleteMin(M--);
		root1 = Find(Edge[Edgeid].n1);
		root2 = Find(Edge[Edgeid].n2);
		if(root1 != root2)
		{
			if(Edge[Edgeid].w > max_w)
				max_w = Edge[Edgeid].w;	
			
			Edge[Edgeid].flag = 1;
			++cnt;
			Union(root1, root2);
		}
	}
}


int main()
{
	int N, M, i, cnt;
	scanf("%d%d", &N, &M);
	Init(N, M);
	for(i = M / 2; i > 0; --i)
		PercolateDown(M, i);
	Kruskal(N, M);
	printf("%d\n%d\n", max_w, N - 1);
	for(i = 1, cnt = 0; cnt < N - 1; ++i)
	{
		if(Edge[i].flag)
		{
			++cnt;
			printf("%d %d\n", Edge[i].n1, Edge[i].n2);
		}
	}


	return 0;
}

PS: 该题让我纠结很很久，看了disscus后以为一直WA是oj问题，就没在意打算再做下一个kurskal，一定要AC一道，下面那题样例过了，disscus里有人上传了一组数据也测试通过，但提交却一直WA，郁闷死了。随手又测试一组数据，发现确实是自己错了。鉴于该算法看了好几天，实在不想再对着代码检查了（虽然知道代码一定错了），就用gdb一步一步调试，终于发现实在堆的操作错了，就是代码注释的那里出错，其实不难理解，但很容易相当然就容易犯错。这一次又一次的告诉我，别对自己太自信了，出现WA或者RE很大程度上就是自己的问题，要更耐心一点。╮(╯▽╰)╭哎～此外，还要认真读题，别光急着写代码，很容易一开始就错了o(╯□╰)o。 

/*
poj 1789
time:766ms
memory:30476k
性能有些差啊，主要是该图是个稠密图，应该用prim算法＋邻接矩阵
*/
#include <stdio.h>
#include <string>
#include <iostream>
#include <stdio.h>
using namespace std;

#define MaxNode 2001
#define MaxEdge 1999001

typedef int DisjSet[MaxNode];
typedef int Priority[MaxEdge];

struct EdgeEntry
{
	int n1, n2, w;
};
EdgeEntry Edge[MaxEdge];
string truck_id[MaxNode];
DisjSet s;
Priority H;
int sum;

void Init(int N, int M)
{
	int i, j, n, k = 1;
	for(i = 1; i <= N; ++i)
	{	
		cin >> truck_id[i];
		s[i] = -1;
	}

	for(i = 1; i <= M; ++i)
		Edge[i].w = 0;
	
	for(i = 1; i <= N; ++i)
		for(j = 1; j < i; ++j)
		{
			for(n = 0; n <= 6; ++n)
				Edge[k].w += (truck_id[i][n] != truck_id[j][n]);
			Edge[k].n1 = i;
			Edge[k].n2 = j;
			H[k] = k;
			++k;
		}
		
}	

int Find(int v)
{
	if(s[v] < 0)
		return v;
	else
		return s[v] = Find(s[v]);
}

void Union(int root1, int root2)
{
	if(s[root1] < s[root2])
	{
		s[root1] += s[root2];
		s[root2] = root1;
	}		
	else
	{
		s[root2] += s[root1];
		s[root1] = root2;
	}
}

void PercolateDown(int M, int i)
{	
	int FirstElement = H[i];
	int child;
	for(; 2 * i <= M; i = child)
	{
		child = 2 * i;
		if(2 * i + 1 <= M && Edge[H[2 * i + 1]].w < Edge[H[2 * i]].w)
			++child;
		if(Edge[H[child]].w < Edge[FirstElement].w)
			H[i] = H[child];
		else
			break;
	}
	H[i] = FirstElement;
}

int DeleteMin(int M)
{
	int i, child;
	int MinElement = H[1];
	int LastElement = H[M];

	for(i = 1; i * 2 <= M; i = child)
	{
		child = 2 * i;
		if(2 * i + 1 <= M && Edge[H[2 * i + 1]].w < Edge[H[i * 2]].w)
			++child;
		if(Edge[LastElement].w > Edge[H[child]].w)
			H[i] = H[child];
		else
			break;
	}
	H[i] = LastElement;
	return MinElement;
}

void Kruskal(int N, int M)
{
	int cnt = 0;
	int root1, root2;
	int Edgeid;
	
	while(cnt < N - 1)
	{
		Edgeid = DeleteMin(M--);
		root1 = Find(Edge[Edgeid].n1);
		root2 = Find(Edge[Edgeid].n2);
		if(root1 != root2)
		{			
			sum += Edge[Edgeid].w;
			++cnt;
			Union(root1, root2);
		}
	}
}

int main()
{
	int N, M, i;
	scanf("%d", &N);
	while(N)
	{	
		sum = 0;
		M = (N * N - N) / 2;	
		Init(N, M);
		for(i = M / 2; i > 0; --i)
			PercolateDown(M, i);
		Kruskal(N, M);
		cout << "The highest possible quality is 1/" << sum << "." << endl;
		scanf("%d", &N);
	}
	return 0;
}



mick_seu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
poj 2349 最小生成树
老铁,干了这碗algorithms的博客
01-08 169
点击打开链接 #include #include #include #include using namespace std; typedef pairint,int> PII; const int maxv=500+5; const int maxe=250000+5; struct Edge{ int from,to,weight; }; bool operatorconst Edge &
POJ 2301最小生成树
weixin_44203780的博客
05-08 307
题目链接：https://cn.vjudge.net/problem/POJ-2031 就是n个点之间的最短距离，跑最小生成树，WA了七发，在于输出 1.G++ 的double类型printf输出用%f，而C++都用%lf（找了半天原因） 求出球心距离，然后减去半径和，小于0就dis为0。 #include<queue> #include<iostream> #i...
POJ 2421 最小生成树
韩小侠的专栏 已迁移至lssea.com
08-19 694
题意：给出每两个城市间建路的花费和已经拥有的路，求最小花费让图连通。 最小生成树。。 #include #include #include #include using namespace std; const int maxv=105,maxe=10005; struct node { int w,to,next,f; } e[maxe]; int head[maxv],dis[m
POJ3026(最小生成树)
shui2104的博客
07-13 181
POJ3026(最小生成树) Borg Maze Description The Borg is an immensely powerful race of enhanced humanoids from the delta quadrant of the galaxy. The Borg collective is the term used to describe the group consciousness of the Borg civilization. Each Borg individua
最小生成树模板 POJ——1258
weixin_40488730的博客
08-23 382
最小生成树是一个比较简单数据结构，形成最小生成树的方式有两种。 最小生成树是有图生成树，保证树的每条边的权值之和最小的生成树就叫做最小生成树，这一类的题目起初比较基础，主要是熟悉模板，POJ 1258 也就是这样的题目，非常适合刚刚学习的人。 两种方法的思路分别是找边和找点，简单点说就是，找到全集中最小的边（或者是距离最近的点），将他们连接起来，最终形成的树就是最小生成树。 第一种方法，pr...
poj1251 最小生成树
05-27
标题“poj1251 最小生成树”是一个编程竞赛题目，来源于著名的在线编程平台POJ（Programming Online Judge）。这个题目主要涉及图论中的一个经典算法问题——最小生成树（Minimum Spanning Tree, MST）。在图论中，...
POJ 1789 最小生成树之prim算法
04-12
标题中的“POJ 1789 最小生成树之prim算法”指的是一个在线编程竞赛题目，来源于普林斯顿开放在线课程（POJ）平台。该题目要求参赛者实现Prim算法，这是一种解决图论问题中寻找最小生成树的经典算法。最小生成树是在...
POJ 1751 求最小生成树prim算法(JAVA)
04-12
标题 "POJ 1751 求最小生成树Prim算法(JAVA)" 提到的是一个编程挑战，涉及图论中的经典算法——Prim算法。在计算机科学中，Prim算法是用于寻找加权无向图的最小生成树的一种有效方法。最小生成树是一棵树形结构，...
poj2485.rar_poj2485
09-19
总结来说，这个压缩包提供了一个使用最小生成树算法解决POJ2485题目的实例，它涉及了图论、贪心算法、C++编程和在线编程竞赛实践等多个IT领域的知识点。通过分析和学习这个解题代码，我们可以加深对最小生成树算法的...
Poj3254.rar_poj3254
最新发布
09-21
4. **图论**：若题目涉及到网络流、最短路径、最小生成树等问题，那么图论的知识是必不可少的。Dijkstra算法、Floyd算法、Prim算法或Kruskal算法可能被应用。 5. **数学知识**：许多编程问题都涉及数学，比如数论、...
POJ1251最小生成树
salmonwilliam的博客
05-11 288
Description The Head Elder of the tropical island of Lagrishan has a problem. A burst of foreign aid money was spent on extra roads between villages some years ago. But the jungle overtakes roads relentlessly, so the large road network is too expensive
POJ_1789_最小生成树
chrishuimin的博客
08-05 204
Description Advanced Cargo Movement, Ltd. uses trucks of different types. Some trucks are used for vegetable delivery, other for furniture, or for bricks. The company has its own code describing each
【唯一最小生成树】POJ 1679
leolin_的专栏
03-08 609
判断MST时候唯一，用prime算法，复杂度O(n^2) #define N 105 int n,m; int dis[N],g[N][N]; bool vis[N]; int mx[N][N];//记录路径i-j最大的边值 int pre[N];//记录最小生成树路径 bool intree[N][N];//判断哪些边属于MST int prime(int s){ int i,j;
POJ 2235 Frogger 最小生成树 Kruskal && Prim
jianjun的专栏
08-13 886
Frogger 最小生成树 Kruscal && Prim 给出两只青蛙的坐标A、B，和其他的n-2个坐标，任一两个坐标点间都是双向连通的。 显然从A到B存在至少一条的通路，每一条通路的元素都是这条通路中前后两个点的距离， 这些距离中又有一个最大距离。 要求: 他最小的弹跳距离是多少（即最短路径中的最长边）。 在生成最小生成树时，只要 A,B 连一起后，其余的点就不用再连 （不需要把所有的点都连起来） 最小生成树 Kruscal rim 模
POJ_1251 （Java代码）
qq_36706625的博客
03-21 227
POJ_1251链接 （最小生成树问题）我写的是java代码、关于java自定义类型的编译器的、我弄了好久、现在总算通过了、自己也get了一个新知识、哈哈import java.util.Collections; import java.util.Comparator; import java.util.HashMap; import java.util.LinkedList; import ja...
POJ1251Jungle Roads(最小生成树)
Rain
01-30 3313
题目大意：首先给你一个图，需要你求出最小生成树，输入N个节点，用大写字母表示了节点，然后节点与节点之间有权值。 比如有9个节点，然后接下来有n-1行表示了边的情况，拿第一行举例 A 2 B 12 I 25 表示A有两个邻点，B和I，AB权值是12，AI权值是25 邻接矩阵prime: #include #include #include using namespace std
最小生成树-两种算法复杂度比较 poj-1258,2485
蓦然回首
08-20 5644
1.Prim算法 时间是复杂度O（n2），适合稠密图。 例：Poj–1258 题目大意：n个城市建造光缆，要使这些城市直接通信，并且光缆费用最小。 #include <cstdio> #include <string.h> #define n 10010 #define inf 100010 int a[n][n],ans; bool vis[n],t; int dis[n]; bool pr
poj1258 最小生成树
Joel
01-21 192
题目链接在这里 题目描述： John要给村民通宽带！他现在已经有了一个高速网络了，现在想将村民相互连接起来。现给出村民之间的距离，求将他们连接起来的最小花费为多少。 思路分析： 最小生成树，盘它就完事了。 代码如下： #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;iostream&gt; #include ...
POJ - 1251（Jungle Roads）(最小生成树.krustal)
WQN20172674的博客
08-21 344
Jungle Roads 题目链接： http://poj.org/problem?id=1251 题目： Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 31876   Accepted: 14909 Description The Head Elder of the tr...
使用优先队列实现Prim算法求最小生成树
在POJ3159的Candies问题中，Dijkstra算法被用来解决类似最小生成树的问题，利用优先队列优化查找过程。 动态规划在这个问题中的应用可能是指在特定约束下寻找最小生成树，例如在保证每个顶点度数不超过某个阈值的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值