最小生成树——Prim、Kruskal

1、问题

2、算法标签

1、Prim
2、Kruskal

3、实现代码

#include<iostream>
#include<iomanip>
#include<algorithm>
#include<cstring>
#include<vector>
#include<deque>
#include<set>
#include<queue>
#include<map>
#include<stack> 
#include<cmath>
#include<time.h>
#include<iomanip>
using namespace std;
typedef long long int ll;
#define MAX 1000000
/*
  A B C D E F G 
A M 2 M 5 M 8 M
B 2 M 7 7 2 M M
C M 7 M M 3 M M
D 5 7 M M 6 7 3 
E M 2 3 6 M M 4
F 8 M M 7 M M 4
G M M M 3 4 4 M
*/

void prim(){
	cout<<"==============Prim算法构建最小生成树=============="<<endl;
	int nums[7][7]={{MAX,2,MAX,5,MAX,8,MAX},
					{2,MAX,7,7,2,MAX,MAX},
					{MAX,7,MAX,MAX,3,MAX,MAX},
					{5,7,MAX,MAX,6,7,3},
					{MAX,2,3,6,MAX,MAX,4},
					{8,MAX,MAX,7,MAX,MAX,4},
					{MAX,MAX,MAX,3,4,4,MAX}};
	vector<int> tree(1,0);
	int isintree[7]={1,0,0,0,0,0,0};
	char pointname[7]={'A','B','C','D','E','F','G'};
	int totalvalue=0;
	cout<<"加入"<<"A"<<endl;
	while(tree.size()<7){
		int next=0;
		int nextvalue=MAX;
		for(int i=0;i<tree.size();i++){
			for(int j=0;j<7;j++){
				if(!isintree[j]&&nums[tree[i]][j]<nextvalue){
					nextvalue=nums[tree[i]][j];
					next=j;
				}
			}
		}
		cout<<"加入"<<pointname[next]<<endl;
		totalvalue+=nextvalue;
		isintree[next]=1;
		tree.push_back(next);
	}
	cout<<"Prim算法构建最小生成树路径权值为："<<totalvalue<<endl; 
}


typedef struct{
	char p1;
	char p2;
	int edge;
	void ini(char a, char b,int l){
		p1=a;
		p2=b;
		edge=l;
	}
}node; 

bool cmp(node a,node b){
	return a.edge<b.edge;
}

void init(node nd[12]){
	nd[0].ini('A','B',2);
	nd[1].ini('B','C',7);
	nd[2].ini('A','D',5);
	nd[3].ini('B','D',7);
	nd[4].ini('B','E',2);
	nd[5].ini('C','E',3);
	nd[6].ini('A','E',8);
	nd[7].ini('F','D',7);
	nd[8].ini('D','E',6);
	nd[9].ini('E','G',4);
	nd[10].ini('D','G',3);
	nd[11].ini('F','G',4);
	sort(nd,nd+12,cmp);
}

int findfar(int far[],int p){
	if(far[p]!=p){
		far[p]=findfar(far,far[p]);
	}
	return far[p];
}

int connect(int far[],int pa,int pb){
	if(far[pa]==pa&&far[pb]==pb){
		far[pb]=far[pa];
	}
	else if(far[pa]!=pa&&far[pb]==pb){
		far[pb]=findfar(far,pa);
	}
	else if(far[pa]==pa&&far[pb]!=pb){
		far[pa]=findfar(far,pb);
	}
	else{
		int tempfar=findfar(far,pb);
		far[tempfar]=findfar(far,pa);
	}
}


void Kruskal(){
	cout<<"==============Kruskal算法构建最小生成树=============="<<endl;
	node nd[12];
	init(nd);
	int totalvalue=0;
	int far[7]={0,1,2,3,4,5,6};
	for(int i=0,time=0;i<12&&time<7;i++){
		int pa=nd[i].p1-'A';
		int pb=nd[i].p2-'A';
		if(findfar(far,pa)!=findfar(far,pb)){
			connect(far,pa,pb);
			cout<<"加入边："<<nd[i].p1<<"--"<<nd[i].p2<<endl;
			totalvalue+=nd[i].edge;
			time++;
		}
	}
	cout<<"Kruskal算法构建最小生成树路径权值为："<<totalvalue<<endl; 
}

 
int main(){
	//算法开始起始时间 
	clock_t start_time = clock(); 
	//调用归并排序算法函数 
	prim();
	//算法完成截止时间 
	clock_t end_time = clock();
	cout<<"Prim算法构建最小生成树消耗时间为："<<(end_time-start_time)<<"ms!"<<endl<<endl;
	
	//算法开始起始时间 
	start_time = clock(); 
	//调用归并排序算法函数 
	Kruskal();
	//算法完成截止时间 
	end_time = clock();
	cout<<"Kruskal算法构建最小生成树消耗时间为："<<(end_time-start_time)<<"ms!"<<endl;
	return 0;
}