hud1875

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;
}