hud1875

最新推荐文章于 2022-06-23 01:01:30 发布

原创最新推荐文章于 2022-06-23 01:01:30 发布 · 430 阅读

CC 4.0 BY-SA版权

本文介绍了两种经典的最小生成树算法：Prim算法和Kruskal算法。这两种算法分别采用贪心策略来寻找图中所有顶点组成的权重最小的树形子图。Prim算法从一个顶点开始逐步增加新的顶点和边；而Kruskal算法则按边的权重从小到大排序，依次加入不会形成环的边。

1.Prim算法

#include<iostream>
#include<math.h>
using namespace std;
#define MAX_SIZE 102
struct Point{
	double x, y;
};
bool visit[MAX_SIZE];         //记录点j是否在树中
int Parent[MAX_SIZE];        //记录父节点
double LowCost[MAX_SIZE];    //记录i到树最短距离
double Prim(Point *P,int n);
int main(){
	Point  P[MAX_SIZE];
	int T, i, c;
	double res;
	scanf("%d",&T);
	while (T--){
		scanf("%d", &c);
		for (i = 1; i <= c; i++)
			scanf("%f%f",&P[i].x,&P[i].y);      //输入坐标
		res = Prim(P, c);
		if (res < 0.00)
			printf("oh!\n");
		else
			printf("%.1f\n", 100 * res);
	}
	return 0;
}
double Distance(Point&a, Point&b){   //计算a,b两点距离
	return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
}
double Prim(Point *P, int n){
	int i, j, k, pos;
	double ans, dis, NowMin;
	for (i = 1; i <= n; i++)
		LowCost[i] = 1.00*INT_MAX;      //赋值为无穷
	memset(visit, 0, sizeof(visit));
	j = 1;
	Parent[j] = -1;    //设置为根结点   
	LowCost[j] = 0.00;
	ans =dis=0.00;
	visit[j] = 1;
  //将顶点1设置为根
	for (i = 2;i <= n; i++){
		for (k = 1; k <= n; k++){
			dis = Distance(P[j], P[k]);
			if (!visit[k] && dis >= 10.00&&dis <= 1000.00&&dis < LowCost[k]){
				Parent[k] = j;
				LowCost[k] = dis;
			}
		}
		pos = 1, NowMin = 1.00*INT_MAX;
		for (k = 1; k <= n; k++){
			if (!visit[k] && LowCost[k] < NowMin){
				pos = k;
				NowMin = LowCost[k];
			}
		}
		if (pos == 1)
			break;                     //这种情况说明没有可以连接的边了
		LowCost[pos] = 0.00;
		visit[pos] = 1;                   //将顶点pos加入到树中
		ans+= Distance(P[Parent[pos]], P[pos]);
		j = pos;                       //更新j
	}
	if (i <= n)                        //图连不通
		return -1.00;
	else
		return ans;
}

2.Kruskal算法

#include<iostream>
#include<queue>
#include<math.h>
using namespace std;
#define MAX_SIZE 102
struct Point{
	double x, y;
};
struct Edge{
	double l;
	int v, w;
	bool operator<(const Edge&a)const{
		return l>a.l;
	}
};
int Parent[MAX_SIZE]; 
double Kruskal(priority_queue<Edge>&MinHeap,int n);
int getParent(int i);
bool Union(int i,int j);
double Distance(Point&a, Point&b){   //计算a,b两点距离
	return sqrt((a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
}
int main(){
	Point  P[MAX_SIZE];
	priority_queue<Edge>MinHeap;
	int T, i,j, c;
	double res,dis;
	Edge edge;
	scanf("%d",&T);
	while (T--){
		scanf("%d", &c);
		for (i = 1; i <= c; i++)
			scanf("%lf%lf", &P[i].x, &P[i].y);      //输入坐标
		memset(Parent, -1, sizeof(Parent));        //初始化
		for (i = 1; i <= c;i++)
		for (j = i + 1; j <= c; j++){
			dis = Distance(P[i], P[j]);
			if (dis >= 10.00&&dis <= 1000.00){
				edge.v = i;
				edge.w = j;
				edge.l = dis;
				MinHeap.push(edge);
			}
		}
		res = Kruskal(MinHeap,c);
		if (res < 0.00)
			printf("oh!\n");
		else
			printf("%.1f\n", 100 * res);
	}
	return 0;
}
double Kruskal(priority_queue<Edge>&MinHeap,int n) {
	Edge edge;
	int  m;
	double res=0.00;
	m = 0;
	while (!MinHeap.empty()){
		edge = MinHeap.top();
		MinHeap.pop();
		if (!Union(edge.v, edge.w)){
			m++;                //m记录已连接的边数
			res += edge.l;
		}
	}
	if (m == n - 1)
		return res;
	return -1.00;
}
int getParent(int i){
	if (Parent[i] == -1)
		return i;
	return Parent[i] = getParent(Parent[i]);
}
bool Union(int i, int j){
	i = getParent(i);
	j = getParent(j);
	if (i == j)
		return true;
	Parent[i] = j;
	return false;
}