图的最小生成树

1.Krustal 算法
1）、算法过程：对图的所有边进行从小到大的排序，然后往图中点加边，如果加入的边会形成一个回路，则排除，不能构成的话则放入图内，
2）、key : 检验是否构成回路的算法
3）、代码：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;

int arr[502][502];
int vertice[502];
int father[101];

int _max;

class Edge {
public:
	int a;
	int b;
	int value;
	friend bool operator<(Edge e1, Edge e2) {
		return e1.value < e2.value;
	}
	Edge(int a, int b, int value) : a(a), b(b), value(value) {}

};

int getfather(int x) {   //递归算法找父节点
	return (father[x] == x)? x : getfather(father[x]);
}

int Krustal(int n,vector<Edge>& vec) {
	
	for(int i =1;i<=n;i++) {
		father[i] = i;
	}        //  线性表构建树 
	
	for(int j = 0;j<vec.size();j++) {      //需要选N-1条边出来 
		
		int x = getfather(vec[j].a);
		int y = getfather(vec[j].b);
		if(x != y) {
			_max = vec[j].value;
			father[x] = y;             //是否能够构成回路操作化简为根节点与子集的关系 
		}
	}
	return _max;
}

int main() {
	int num;
	cin >> num;
	while (num--) {
		_max = -1;
		memset(arr, 0, sizeof(arr));
		memset(vertice, 0, sizeof(vertice));
		vector<Edge> vec;
		int N;
		cin >> N;

		for (int i = 1; i <= N; i++) {
			for (int j = 1; j <= N; j++) {
				cin >> arr[i][j];
				if (j >= i) {
					Edge e(i, j, arr[i][j]);
					if (e.value != 0)
						vec.push_back(e);
				}
			}
		}

		int len = 0;
		sort(vec.begin(), vec.end());
		int max = Krustal(N,vec);

		cout << max << endl;
		if (num != 0) cout << endl;

	}
}

2.Prim算法
1）、算法过程:首先任意选取一个点加入目标点集V中，然后在于V中点邻接的边中选一个最小的边，把点再添加进V中，如此重复几次，当V中点集有全部点时，结束。
          换言之：首先置S={1}，然后，只要S是V的真子集，就作如下的贪心选择：选取满足条件i属于S，j属于V-S，且c[i][j]最小的边，将顶点j添加到S中。这个过程一直进行到S=V时为止
2）、key :  选最小的边 ：找最小边 不等于  排序
3）、代码：
 

#include<iostream>
#include<cstring>
using namespace std;

#define max 101
int arr[max][max];
int visit[max];
int father[max];

int main() {
	for(int i = 0; i < max; i++) {
		for(int j = 0;j < max; j++) {
			arr[i][j] = 0;
		}
	}
	memset(visit,0,sizeof(visit));
	memset(father,0,sizeof(father));
	int n ;
	cin >> n;
	for(int i = 1 ;i <= n ;i++) {
		for(int j = 1; j<= n ;j++) {
			cin >> arr[i][j];
		}
	}
	
	visit[1] = 1;
	int vertice[max];
	for(int i = 1 ;i <= n ;i++) {
		vertice[i] = arr[1][i];
	}    //初始化
	
	
	for(int i = 1 ;i <= n; i++) {
		
		int min = 9999;
		int j = 0;
		for(int m = 1; m <= n; m++) {
			if(!visit[m] && vertice[m] < min) {
				min = vertice[m];
				j = m;
			}
		}                    //选最短的边！！！！不用排序，不用排序
		visit[j] = 1;
		printf("%d,%d\n",j,father[j]);
		
		for(int m = 1; m<= n; m++) {
			if(!visit[m] && arr[j][m] < vertice[m]){
				vertice[m] = arr[j][m];
				father[m]=j;
			}
		}                    //因为新加入了一个顶点，所以对最短边数组进行更新
	}
}