最小生成树

小学期学的算法和做OJ题的各种经验总结

prim:时间复杂度为O(n²)。与图中边数无关，该算法适合于稠密图。

kruskal:需要对图的边进行访问，所以时间复杂度只和边有关系，可以证明其时间复杂度为O(|E|log|E|)。适合稀疏图。

Prim算法（点遍历，距离小的点优先）

• 任取一个点开始，遍历所有相邻点，加入优先队列（按边权小的优先）
• 不断从队列中取点i，遍历i的所有不在生成树内的相邻点，加入优先队列，已经在树内则跳过。
• 直到队列取空。
• 图示：

Kruskal算法（边先排序再遍历，不能构成环（并查集）的边优先）

1. 初始化（只用调用init）
2. 判断：遍历所有的边，如果该边连接的两个点不在集合中就加入集合并取该边

//不连通的条件：e != v-1
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>

using namespace std;

//并查集用来找环
const int MAXV = 10005;
int p[MAXV];

//默认一开始所有点都是独立的
void init(int v) {
	for (int i = 0; i <= v; i++) {
		p[i] = i;
	}
}

int find(int x) {
	if (p[x] == x) return x;
	int rootx = p[x];
	while (rootx != p[rootx]) {
		rootx = p[rootx];
	}
	return p[x] = rootx;
}

bool same(int x, int y) {
	return find(x) == find(y);
}

bool unite(int x, int y) {
	x = find(x); y = find(y);
	if (x == y) return false;
	p[x] = y;
	return true;
}

struct edge
{
	int from;
	int to;
	int cost;

	edge(int f = 0, int t = 0, int c = 0) :from(f), to(t), cost(c) {};

};//edges[MAXE];
vector<edge> edges;

bool cmp(const edge &e1, const edge &e2) {
	return e1.cost < e2.cost;
}

//v:顶点数
int kruskal(int v) {
	sort(edges.begin(), edges.end(), cmp);//按权重排序
	init(v);
	int res = 0;
	for (int i = 0; i < edges.size(); i++) {
		if (unite(edges[i].from, edges[i].to))//unite成功，不在一个集合里
			res += edges[i].cost;
	}
	return res;
}

void addEdge(const int &f, const int &t, const int &cost) {
	edges.push_back(edge(f, t, cost));
}

int main() {
	int v;//顶点数
	//int e;//边数

	//初始化边数组----
	v = 5;
	//单向边就行
	edges.push_back(edge(1, 2, 1));
	edges.push_back(edge(1, 3, 2));
	edges.push_back(edge(1, 5, 4));
	edges.push_back(edge(2, 3, 1));
	edges.push_back(edge(3, 5, 6));
	edges.push_back(edge(2, 4, 2));
	edges.push_back(edge(3, 4, 3));
	edges.push_back(edge(4, 5, 5));
	//----
    
	int res = kruskal(v+5);


	cout << "最小生成树权重=" << res;

	return 0;
}